#include "tdiconn.h"
#include "debug.h"
-NTSTATUS WarmSocketForBind( PAFD_FCB FCB )
+NTSTATUS WarmSocketForBind(PAFD_FCB FCB)
{
NTSTATUS Status;
AFD_DbgPrint(MID_TRACE,("Called (AF %d)\n",
FCB->LocalAddress->Address[0].AddressType));
- if( !FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer )
+ if (!FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer)
{
AFD_DbgPrint(MID_TRACE,("Null Device\n"));
return STATUS_NO_SUCH_DEVICE;
}
- if( !FCB->LocalAddress )
+ if (!FCB->LocalAddress)
{
AFD_DbgPrint(MID_TRACE,("No local address\n"));
return STATUS_INVALID_PARAMETER;
return Status;
}
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdBindSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_BIND_DATA BindReq;
AFD_DbgPrint(MID_TRACE,("Called\n"));
DbgPrint("[AFD, AfdBindSocket] Called\n");
- if ( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return LostSocket( Irp );
- if ( !(BindReq = LockRequest( Irp, IrpSp )) )
+ if (!(BindReq = (PAFD_BIND_DATA)LockRequest(Irp, IrpSp)) )
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
- if ( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
- FCB->LocalAddress = TaCopyTransportAddress( &BindReq->Address );
+ if (FCB->LocalAddress )
+ ExFreePool(FCB->LocalAddress);
+ FCB->LocalAddress = TaCopyTransportAddress(&BindReq->Address);
if (FCB->LocalAddress)
Status = TdiBuildConnectionInfo( &FCB->AddressFrom,
FCB->LocalAddress );
if (NT_SUCCESS(Status))
- Status = WarmSocketForBind( FCB );
+ Status = WarmSocketForBind(FCB);
AFD_DbgPrint(MID_TRACE,("FCB->Flags %x\n", FCB->Flags));
/* MSAFD relies on us returning the address file handle in the IOSB */
return UnlockAndMaybeComplete( FCB, Status, Irp, (ULONG_PTR)FCB->AddressFile.Handle );
}
-
#include "tdiconn.h"
#include "debug.h"
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdGetConnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (FCB->ConnectOptionsSize == 0)
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PVOID ConnectOptions = LockRequest(Irp, IrpSp);
UINT ConnectOptionsSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!ConnectOptions)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
FCB->ConnectOptions = ExAllocatePool(PagedPool, ConnectOptionsSize);
- if (!FCB->ConnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ if (!FCB->ConnectOptions)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
RtlCopyMemory(FCB->ConnectOptions,
ConnectOptions,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
- PUINT ConnectOptionsSize = LockRequest(Irp, IrpSp);
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
+ PUINT ConnectOptionsSize = (PUINT)LockRequest(Irp, IrpSp);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!ConnectOptionsSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
FCB->ConnectOptions = ExAllocatePool(PagedPool, *ConnectOptionsSize);
- if (!FCB->ConnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ if (!FCB->ConnectOptions)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
FCB->ConnectOptionsSize = *ConnectOptionsSize;
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdGetConnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (FCB->ConnectDataSize == 0)
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
ASSERT(FCB->ConnectData);
- if (FCB->FilledConnectData < BufferSize) BufferSize = FCB->FilledConnectData;
+ if (FCB->FilledConnectData < BufferSize)
+ BufferSize = FCB->FilledConnectData;
RtlCopyMemory(Irp->UserBuffer,
FCB->ConnectData,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PVOID ConnectData = LockRequest(Irp, IrpSp);
UINT ConnectDataSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!ConnectData)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
FCB->ConnectData = ExAllocatePool(PagedPool, ConnectDataSize);
- if (!FCB->ConnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ if (!FCB->ConnectData)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- RtlCopyMemory(FCB->ConnectData,
- ConnectData,
- ConnectDataSize);
+ RtlCopyMemory(FCB->ConnectData, ConnectData, ConnectDataSize);
FCB->ConnectDataSize = ConnectDataSize;
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
- PUINT ConnectDataSize = LockRequest(Irp, IrpSp);
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
+ PUINT ConnectDataSize = (PUINT)LockRequest(Irp, IrpSp);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!ConnectDataSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
FCB->ConnectData = ExAllocatePool(PagedPool, *ConnectDataSize);
- if (!FCB->ConnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ if (!FCB->ConnectData)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
FCB->ConnectDataSize = *ConnectDataSize;
{
NTSTATUS Status;
- if( !FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer )
+ if (!FCB->TdiDeviceName.Length || !FCB->TdiDeviceName.Buffer)
{
AFD_DbgPrint(MID_TRACE,("Null Device\n"));
return STATUS_NO_SUCH_DEVICE;
&FCB->Connection.Handle,
&FCB->Connection.Object );
- if( NT_SUCCESS(Status) )
+ if (NT_SUCCESS(Status))
{
Status = TdiAssociateAddressFile( FCB->AddressFile.Handle,
FCB->Connection.Object );
FCB->Recv.Size = FCB->Send.Size;
/* Allocate the receive area and start receiving */
- FCB->Recv.Window =
- ExAllocatePool( PagedPool, FCB->Recv.Size );
+ FCB->Recv.Window = ExAllocatePool(PagedPool, FCB->Recv.Size);
- if( !FCB->Recv.Window ) return STATUS_NO_MEMORY;
+ if (!FCB->Recv.Window)
+ return STATUS_NO_MEMORY;
- FCB->Send.Window =
- ExAllocatePool( PagedPool, FCB->Send.Size );
+ FCB->Send.Window = ExAllocatePool(PagedPool, FCB->Send.Size);
- if( !FCB->Send.Window ) {
- ExFreePool( FCB->Recv.Window );
- FCB->Recv.Window = NULL;
- return STATUS_NO_MEMORY;
+ if (!FCB->Send.Window)
+ {
+ ExFreePool( FCB->Recv.Window );
+ FCB->Recv.Window = NULL;
+ return STATUS_NO_MEMORY;
}
FCB->State = SOCKET_STATE_CONNECTED;
ReceiveComplete,
FCB );
- if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
+ if (Status == STATUS_PENDING)
+ Status = STATUS_SUCCESS;
FCB->PollState |= AFD_EVENT_CONNECT | AFD_EVENT_SEND;
FCB->PollStatus[FD_CONNECT_BIT] = STATUS_SUCCESS;
return Status;
}
-static NTSTATUS NTAPI StreamSocketConnectComplete
+static
+NTSTATUS
+NTAPI
+StreamSocketConnectComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
- PVOID Context ) {
+ PVOID Context )
+{
NTSTATUS Status = Irp->IoStatus.Status;
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
/* I was wrong about this before as we can have pending writes to a not
* yet connected socket */
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
AFD_DbgPrint(MID_TRACE,("Irp->IoStatus.Status = %x\n",
ASSERT(FCB->ConnectIrp.InFlightRequest == Irp);
FCB->ConnectIrp.InFlightRequest = NULL;
- if( FCB->State == SOCKET_STATE_CLOSED )
+ if (FCB->State == SOCKET_STATE_CLOSED)
{
/* Cleanup our IRP queue because the FCB is being destroyed */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_CONNECT] ) )
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_CONNECT]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_CONNECT]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrp->IoStatus.Information = 0;
if( NextIrp->MdlAddress )
- UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation(NextIrp));
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
- SocketStateUnlock( FCB );
+
+ SocketStateUnlock( FCB );
return STATUS_FILE_CLOSED;
}
- if( !NT_SUCCESS(Irp->IoStatus.Status) )
+ if (!NT_SUCCESS(Irp->IoStatus.Status))
{
FCB->PollState |= AFD_EVENT_CONNECT_FAIL;
FCB->PollStatus[FD_CONNECT_BIT] = Irp->IoStatus.Status;
}
/* Succeed pending irps on the FUNCTION_CONNECT list */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_CONNECT] ) )
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_CONNECT]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_CONNECT]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
DbgPrint("[AFD, StreamSocketConnectComplete] Completing connect 0x%x\n", NextIrp);
NextIrp->IoStatus.Status = Status;
- NextIrp->IoStatus.Information = NT_SUCCESS(Status) ? ((ULONG_PTR)FCB->Connection.Handle) : 0;
+ NextIrp->IoStatus.Information = (NT_SUCCESS(Status) ? ((ULONG_PTR)FCB->Connection.Handle) : 0);
- if( NextIrp->MdlAddress )
- UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
- IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation(NextIrp));
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
+ IoCompleteRequest(NextIrp, IO_NETWORK_INCREMENT);
}
- if( NT_SUCCESS(Status) ) {
- Status = MakeSocketIntoConnection( FCB );
+ if (NT_SUCCESS(Status))
+ {
+ Status = MakeSocketIntoConnection(FCB);
- if( !NT_SUCCESS(Status) ) {
- SocketStateUnlock( FCB );
- return Status;
- }
+ if (!NT_SUCCESS(Status))
+ {
+ SocketStateUnlock(FCB);
+ return Status;
+ }
- FCB->FilledConnectData = MIN(FCB->ConnectInfo->UserDataLength, FCB->ConnectDataSize);
+ FCB->FilledConnectData = MIN(FCB->ConnectInfo->UserDataLength,
+ FCB->ConnectDataSize);
if (FCB->FilledConnectData)
{
RtlCopyMemory(FCB->ConnectData,
FCB->FilledConnectData);
}
- FCB->FilledConnectOptions = MIN(FCB->ConnectInfo->OptionsLength, FCB->ConnectOptionsSize);
+ FCB->FilledConnectOptions = MIN(FCB->ConnectInfo->OptionsLength,
+ FCB->ConnectOptionsSize);
if (FCB->FilledConnectOptions)
{
RtlCopyMemory(FCB->ConnectOptions,
- FCB->ConnectInfo->Options,
- FCB->FilledConnectOptions);
+ FCB->ConnectInfo->Options,
+ FCB->FilledConnectOptions);
}
- if( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
- NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
- NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP,
- Tail.Overlay.ListEntry);
- AFD_DbgPrint(MID_TRACE,("Launching send request %x\n", NextIrp));
- Status = AfdConnectedSocketWriteData
- ( DeviceObject,
- NextIrp,
- IoGetCurrentIrpStackLocation( NextIrp ),
- FALSE );
- }
-
- if( Status == STATUS_PENDING )
- Status = STATUS_SUCCESS;
+ if (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+
+ AFD_DbgPrint(MID_TRACE,("Launching send request %x\n", NextIrp));
+
+ Status = AfdConnectedSocketWriteData(DeviceObject,
+ NextIrp,
+ IoGetCurrentIrpStackLocation( NextIrp ),
+ FALSE);
+ }
+
+ if (Status == STATUS_PENDING)
+ Status = STATUS_SUCCESS;
}
- SocketStateUnlock( FCB );
+ SocketStateUnlock(FCB);
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
/* Return the socket object for ths request only if it is a connected or
stream type. */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdStreamSocketConnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
NTSTATUS Status = STATUS_INVALID_PARAMETER;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_CONNECT_INFO ConnectReq;
PTDI_CONNECTION_INFORMATION TargetAddress;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
- if( !(ConnectReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
- 0 );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
+
+ if (!(ConnectReq = LockRequest(Irp, IrpSp)))
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Connect request:\n"));
DbgPrint("[AFD, AfdStreamSocketConnect] Connect request:\n");
IrpSp->Parameters.DeviceIoControl.InputBufferLength );
#endif
- if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
+ if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
{
- if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
- FCB->RemoteAddress = TaCopyTransportAddress( &ConnectReq->RemoteAddress );
+ if (FCB->RemoteAddress)
+ ExFreePool(FCB->RemoteAddress);
+
+ FCB->RemoteAddress = TaCopyTransportAddress( &ConnectReq->RemoteAddress );
- if( !FCB->RemoteAddress )
+ if (!FCB->RemoteAddress)
Status = STATUS_NO_MEMORY;
else
Status = STATUS_SUCCESS;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
- switch( FCB->State )
+ switch (FCB->State)
{
case SOCKET_STATE_CONNECTED:
Status = STATUS_SUCCESS;
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_CONNECT );
case SOCKET_STATE_CREATED:
- if( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
+ if (FCB->LocalAddress) ExFreePool(FCB->LocalAddress);
FCB->LocalAddress = TaBuildNullTransportAddress(
ConnectReq->RemoteAddress.Address[0].AddressType);
- if( FCB->LocalAddress )
+ if (FCB->LocalAddress)
{
- Status = WarmSocketForBind( FCB );
+ Status = WarmSocketForBind(FCB);
- if( NT_SUCCESS(Status) )
- FCB->State = SOCKET_STATE_BOUND;
+ if (NT_SUCCESS(Status))
+ FCB->State = SOCKET_STATE_BOUND;
else
- return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
+ return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
}
else
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
/* Drop through to SOCKET_STATE_BOUND */
case SOCKET_STATE_BOUND:
- if( FCB->RemoteAddress )
- ExFreePool( FCB->RemoteAddress );
+ if (FCB->RemoteAddress)
+ ExFreePool(FCB->RemoteAddress);
FCB->RemoteAddress = TaCopyTransportAddress( &ConnectReq->RemoteAddress );
- if( !FCB->RemoteAddress )
+ if (!FCB->RemoteAddress)
{
Status = STATUS_NO_MEMORY;
break;
}
- Status = WarmSocketForConnection( FCB );
+ Status = WarmSocketForConnection(FCB);
- if( !NT_SUCCESS(Status) )
+ if (!NT_SUCCESS(Status))
break;
Status = TdiBuildConnectionInfo(&FCB->ConnectInfo, &ConnectReq->RemoteAddress);
- if( NT_SUCCESS(Status) )
+ if (NT_SUCCESS(Status))
Status = TdiBuildConnectionInfo(&TargetAddress, &ConnectReq->RemoteAddress);
else break;
- if( NT_SUCCESS(Status) )
+ if (NT_SUCCESS(Status))
{
TargetAddress->UserData = FCB->ConnectData;
TargetAddress->UserDataLength = FCB->ConnectDataSize;
if( Status == STATUS_PENDING )
{
- FCB->State = SOCKET_STATE_CONNECTING;
- return LeaveIrpUntilLater(FCB, Irp, FUNCTION_CONNECT);
+ FCB->State = SOCKET_STATE_CONNECTING;
+ return LeaveIrpUntilLater(FCB, Irp, FUNCTION_CONNECT);
}
}
break;
#include "tdiconn.h"
#include "debug.h"
-NTSTATUS NTAPI
-AfdGetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdGetContext(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_INVALID_PARAMETER;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
UINT ContextSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
- if( FCB->ContextSize < ContextSize ) ContextSize = FCB->ContextSize;
+ if (FCB->ContextSize < ContextSize)
+ ContextSize = FCB->ContextSize;
- if( FCB->Context ) {
- RtlCopyMemory( Irp->UserBuffer,
- FCB->Context,
- ContextSize );
- Status = STATUS_SUCCESS;
+ if (FCB->Context)
+ {
+ RtlCopyMemory( Irp->UserBuffer, FCB->Context, ContextSize );
+ Status = STATUS_SUCCESS;
}
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
return UnlockAndMaybeComplete( FCB, Status, Irp, ContextSize );
}
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdGetContextSize( PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp )
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_TOO_SMALL, Irp, sizeof(ULONG));
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, sizeof(ULONG));
}
-NTSTATUS NTAPI
-AfdSetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdSetContext(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PVOID Context = LockRequest(Irp, IrpSp);
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
if (!Context)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- if( FCB->Context ) {
- ExFreePool( FCB->Context );
- FCB->ContextSize = 0;
+ if (FCB->Context)
+ {
+ ExFreePool( FCB->Context );
+ FCB->ContextSize = 0;
}
FCB->Context = ExAllocatePool( PagedPool,
IrpSp->Parameters.DeviceIoControl.InputBufferLength );
- if( !FCB->Context ) return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
+ if ( !FCB->Context )
+ return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
FCB->ContextSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
#include "debug.h"
#include "pseh/pseh2.h"
-NTSTATUS NTAPI
-AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdGetInfo(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_SUCCESS;
- PAFD_INFO InfoReq = LockRequest(Irp, IrpSp);
+ PAFD_INFO InfoReq = (PAFD_INFO)LockRequest(Irp, IrpSp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PLIST_ENTRY CurrentEntry;
AFD_DbgPrint(MID_TRACE,("Called %x %x\n", InfoReq,
InfoReq ? InfoReq->InformationClass : 0));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
if (!InfoReq)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- _SEH2_TRY {
- switch( InfoReq->InformationClass ) {
- case AFD_INFO_RECEIVE_WINDOW_SIZE:
- InfoReq->Information.Ulong = FCB->Recv.Size;
- break;
-
- case AFD_INFO_SEND_WINDOW_SIZE:
- InfoReq->Information.Ulong = FCB->Send.Size;
- AFD_DbgPrint(MID_TRACE,("Send window size %d\n", FCB->Send.Size));
- break;
-
- case AFD_INFO_GROUP_ID_TYPE:
- InfoReq->Information.LargeInteger.u.HighPart = FCB->GroupType;
- InfoReq->Information.LargeInteger.u.LowPart = FCB->GroupID;
- AFD_DbgPrint(MID_TRACE, ("Group ID: %d Group Type: %d\n", FCB->GroupID, FCB->GroupType));
- break;
-
- case AFD_INFO_BLOCKING_MODE:
- InfoReq->Information.Ulong = FCB->BlockingMode;
- break;
-
- case AFD_INFO_RECEIVE_CONTENT_SIZE:
- /* Only touch InfoReq if a socket has been set up.
- Behaviour was verified under WinXP SP2. */
- if(FCB->AddressFile.Object)
- InfoReq->Information.Ulong = FCB->Recv.Content - FCB->Recv.BytesUsed;
-
- break;
-
- case AFD_INFO_SENDS_IN_PROGRESS:
- InfoReq->Information.Ulong = 0;
-
- /* Count the queued sends */
- CurrentEntry = FCB->PendingIrpList[FUNCTION_SEND].Flink;
- while (CurrentEntry != &FCB->PendingIrpList[FUNCTION_SEND])
- {
- InfoReq->Information.Ulong++;
- CurrentEntry = CurrentEntry->Flink;
- }
-
- break;
-
- default:
- AFD_DbgPrint(MID_TRACE,("Unknown info id %x\n",
- InfoReq->InformationClass));
+ _SEH2_TRY
+ {
+ switch( InfoReq->InformationClass )
+ {
+ case AFD_INFO_RECEIVE_WINDOW_SIZE:
+ InfoReq->Information.Ulong = FCB->Recv.Size;
+ break;
+
+ case AFD_INFO_SEND_WINDOW_SIZE:
+ InfoReq->Information.Ulong = FCB->Send.Size;
+ AFD_DbgPrint(MID_TRACE,("Send window size %d\n", FCB->Send.Size));
+ break;
+
+ case AFD_INFO_GROUP_ID_TYPE:
+ InfoReq->Information.LargeInteger.u.HighPart = FCB->GroupType;
+ InfoReq->Information.LargeInteger.u.LowPart = FCB->GroupID;
+ AFD_DbgPrint(MID_TRACE, ("Group ID: %d Group Type: %d\n", FCB->GroupID, FCB->GroupType));
+ break;
+
+ case AFD_INFO_BLOCKING_MODE:
+ InfoReq->Information.Ulong = FCB->BlockingMode;
+ break;
+
+ case AFD_INFO_RECEIVE_CONTENT_SIZE:
+ /* Only touch InfoReq if a socket has been set up.
+ Behaviour was verified under WinXP SP2. */
+ if(FCB->AddressFile.Object)
+ InfoReq->Information.Ulong = FCB->Recv.Content - FCB->Recv.BytesUsed;
+
+ break;
+
+ case AFD_INFO_SENDS_IN_PROGRESS:
+ InfoReq->Information.Ulong = 0;
+
+ /* Count the queued sends */
+ CurrentEntry = FCB->PendingIrpList[FUNCTION_SEND].Flink;
+ while (CurrentEntry != &FCB->PendingIrpList[FUNCTION_SEND])
+ {
+ InfoReq->Information.Ulong++;
+ CurrentEntry = CurrentEntry->Flink;
+ }
+ break;
+
+ default:
+ AFD_DbgPrint(MID_TRACE,("Unknown info id %x\n",
+ InfoReq->InformationClass));
+ Status = STATUS_INVALID_PARAMETER;
+ break;
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ AFD_DbgPrint(MID_TRACE,("Exception executing GetInfo\n"));
Status = STATUS_INVALID_PARAMETER;
- break;
- }
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
- AFD_DbgPrint(MID_TRACE,("Exception executing GetInfo\n"));
- Status = STATUS_INVALID_PARAMETER;
- } _SEH2_END;
+ }
+ _SEH2_END;
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
-NTSTATUS NTAPI
-AfdSetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdSetInfo(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_SUCCESS;
- PAFD_INFO InfoReq = LockRequest(Irp, IrpSp);
+ PAFD_INFO InfoReq = (PAFD_INFO)LockRequest(Irp, IrpSp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!InfoReq)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- _SEH2_TRY {
- switch (InfoReq->InformationClass) {
- case AFD_INFO_BLOCKING_MODE:
- AFD_DbgPrint(MID_TRACE,("Blocking mode set to %d\n", InfoReq->Information.Ulong));
- FCB->BlockingMode = InfoReq->Information.Ulong;
- break;
- default:
- AFD_DbgPrint(MIN_TRACE,("Unknown request %d\n", InfoReq->InformationClass));
- break;
- }
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
- Status = STATUS_INVALID_PARAMETER;
- } _SEH2_END;
+ _SEH2_TRY
+ {
+ switch (InfoReq->InformationClass)
+ {
+ case AFD_INFO_BLOCKING_MODE:
+ AFD_DbgPrint(MID_TRACE,("Blocking mode set to %d\n", InfoReq->Information.Ulong));
+ FCB->BlockingMode = InfoReq->Information.Ulong;
+ break;
+ default:
+ AFD_DbgPrint(MIN_TRACE,("Unknown request %d\n", InfoReq->InformationClass));
+ break;
+ }
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ Status = STATUS_INVALID_PARAMETER;
+ }
+ _SEH2_END;
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
}
-NTSTATUS NTAPI
-AfdGetSockName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdGetSockName(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PMDL Mdl = NULL;
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
- if( FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL ) {
- return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
+ if (FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL)
+ {
+ return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
}
Mdl = IoAllocateMdl
FALSE,
NULL );
- if( Mdl != NULL ) {
- _SEH2_TRY {
- MmProbeAndLockPages( Mdl, Irp->RequestorMode, IoModifyAccess );
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
- AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
- Status = _SEH2_GetExceptionCode();
- } _SEH2_END;
-
- if( NT_SUCCESS(Status) ) {
- Status = TdiQueryInformation
- ( FCB->Connection.Object ? FCB->Connection.Object : FCB->AddressFile.Object,
- TDI_QUERY_ADDRESS_INFO,
- Mdl );
+ if( Mdl != NULL )
+ {
+ _SEH2_TRY
+ {
+ MmProbeAndLockPages( Mdl, Irp->RequestorMode, IoModifyAccess );
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
+
+ if (NT_SUCCESS(Status))
+ {
+ Status = TdiQueryInformation(
+ FCB->Connection.Object ? FCB->Connection.Object : FCB->AddressFile.Object,
+ TDI_QUERY_ADDRESS_INFO,
+ Mdl );
}
- } else
+ }
+ else
Status = STATUS_INSUFFICIENT_RESOURCES;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
-NTSTATUS NTAPI
-AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdGetPeerName(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PMDL Mdl = NULL;
PTDI_CONNECTION_INFORMATION ConnInfo = NULL;
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
-
- if (FCB->RemoteAddress == NULL || FCB->Connection.Object == NULL) {
+ if (FCB->RemoteAddress == NULL || FCB->Connection.Object == NULL)
+ {
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
}
- if(NT_SUCCESS(Status = TdiBuildNullConnectionInfo
- (&ConnInfo,
+ if (NT_SUCCESS(Status = TdiBuildNullConnectionInfo(&ConnInfo,
FCB->RemoteAddress->Address[0].AddressType)))
{
Mdl = IoAllocateMdl(ConnInfo,
if (Mdl)
{
- _SEH2_TRY {
- MmProbeAndLockPages(Mdl, Irp->RequestorMode, IoModifyAccess);
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
- AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
- Status = _SEH2_GetExceptionCode();
- } _SEH2_END;
+ _SEH2_TRY
+ {
+ MmProbeAndLockPages(Mdl, Irp->RequestorMode, IoModifyAccess);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
+ Status = _SEH2_GetExceptionCode();
+ }
+ _SEH2_END;
if (NT_SUCCESS(Status))
{
if (NT_SUCCESS(Status))
{
- if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength >= TaLengthOfTransportAddress(ConnInfo->RemoteAddress))
- RtlCopyMemory(Irp->UserBuffer, ConnInfo->RemoteAddress, TaLengthOfTransportAddress(ConnInfo->RemoteAddress));
+ if (IrpSp->Parameters.DeviceIoControl.OutputBufferLength >=
+ TaLengthOfTransportAddress(ConnInfo->RemoteAddress))
+ RtlCopyMemory(Irp->UserBuffer,
+ ConnInfo->RemoteAddress,
+ TaLengthOfTransportAddress(ConnInfo->RemoteAddress));
else
Status = STATUS_BUFFER_TOO_SMALL;
}
#include "tdiconn.h"
#include "debug.h"
-static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
- PIRP Irp,
- PFILE_OBJECT NewFileObject,
- PAFD_TDI_OBJECT_QELT Qelt ) {
- PAFD_FCB FCB = NewFileObject->FsContext;
+static
+NTSTATUS
+SatisfyAccept
+( PAFD_DEVICE_EXTENSION DeviceExt,
+ PIRP Irp,
+ PFILE_OBJECT NewFileObject,
+ PAFD_TDI_OBJECT_QELT Qelt )
+{
+ PAFD_FCB FCB = (PAFD_FCB)NewFileObject->FsContext;
NTSTATUS Status;
if( !SocketAcquireStateLock( FCB ) )
FCB->Connection = Qelt->Object;
- if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
- FCB->RemoteAddress =
- TaCopyTransportAddress( Qelt->ConnInfo->RemoteAddress );
+ if (FCB->RemoteAddress)
+ ExFreePool( FCB->RemoteAddress );
+
+ FCB->RemoteAddress = TaCopyTransportAddress(Qelt->ConnInfo->RemoteAddress);
- if( !FCB->RemoteAddress )
- Status = STATUS_NO_MEMORY;
+ if (!FCB->RemoteAddress)
+ Status = STATUS_NO_MEMORY;
else
- Status = MakeSocketIntoConnection( FCB );
+ Status = MakeSocketIntoConnection( FCB );
if (NT_SUCCESS(Status))
Status = TdiBuildConnectionInfo(&FCB->ConnectInfo, FCB->RemoteAddress);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
-static NTSTATUS SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt )
+static
+NTSTATUS
+SatisfyPreAccept(PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt)
{
PAFD_RECEIVED_ACCEPT_DATA ListenReceive =
(PAFD_RECEIVED_ACCEPT_DATA)Irp->AssociatedIrp.SystemBuffer;
return STATUS_SUCCESS;
}
-static NTSTATUS NTAPI ListenComplete
+static
+NTSTATUS
+NTAPI
+ListenComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context )
DbgPrint("[AFD, ListenComplete] IoStatus was %x\n", FCB->ListenIrp.Iosb.Status);
Qelt = ExAllocatePool( NonPagedPool, sizeof(AFD_TDI_OBJECT_QELT) );//sizeof(*Qelt) );
- if( !Qelt )
+ if (!Qelt)
{
Status = STATUS_NO_MEMORY;
}
}
/* Satisfy a pre-accept request if one is available */
- if ( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_PREACCEPT] ) &&
+ if (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_PREACCEPT] ) &&
!IsListEmpty( &FCB->PendingConnections ) )
{
PLIST_ENTRY PendingIrp = RemoveHeadList( &FCB->PendingIrpList[FUNCTION_PREACCEPT] );
}
/* Trigger a select return if appropriate */
- if ( !IsListEmpty( &FCB->PendingConnections ) )
+ if (!IsListEmpty( &FCB->PendingConnections))
{
FCB->PollState |= AFD_EVENT_ACCEPT;
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_LISTEN_DATA ListenReq;
AFD_DbgPrint(MID_TRACE,("Called on 0x%x\n", FCB));
DbgPrint("[AfdListenSocket] Called on 0x%x\n", FCB);
- if( !SocketAcquireStateLock( FCB ) )
+ if ( !SocketAcquireStateLock(FCB) )
return LostSocket( Irp );
- if( !(ListenReq = LockRequest( Irp, IrpSp )) )
+ if ( !(ListenReq = (PAFD_LISTEN_DATA)LockRequest(Irp, IrpSp)) )
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- if( FCB->State != SOCKET_STATE_BOUND )
+ if (FCB->State != SOCKET_STATE_BOUND)
{
Status = STATUS_INVALID_PARAMETER;
AFD_DbgPrint(MID_TRACE,("Could not listen an unbound socket\n"));
AFD_DbgPrint(MID_TRACE,("Status from warmsocket %x\n", Status));
DbgPrint("[AfdListenSocket] Status from warmsocket 0x%x\n", Status);
- if ( !NT_SUCCESS(Status) )
+ if (!NT_SUCCESS(Status))
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
Status = TdiBuildNullConnectionInfo(&FCB->ListenIrp.ConnectionCallInfo,
PIO_STACK_LOCATION IrpSp )
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
NTSTATUS Status;
AFD_DbgPrint(MID_TRACE,("Called\n"));
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return LostSocket( Irp );
- if( !IsListEmpty( &FCB->PendingConnections ) )
+ if (!IsListEmpty(&FCB->PendingConnections))
{
PLIST_ENTRY PendingConn = FCB->PendingConnections.Flink;
/* We have a pending connection ... complete this irp right away */
- Status = SatisfyPreAccept
- ( Irp,
- CONTAINING_RECORD
- ( PendingConn, AFD_TDI_OBJECT_QELT, ListEntry ) );
+ Status = SatisfyPreAccept(Irp,
+ CONTAINING_RECORD(PendingConn, AFD_TDI_OBJECT_QELT, ListEntry));
AFD_DbgPrint(MID_TRACE,("Completed a wait for accept\n"));
DbgPrint("[AfdWaitForListen] Completed a wait for accept\n");
- if ( !IsListEmpty( &FCB->PendingConnections ) )
+ if (!IsListEmpty(&FCB->PendingConnections))
{
FCB->PollState |= AFD_EVENT_ACCEPT;
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
PAFD_DEVICE_EXTENSION DeviceExt =
(PAFD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
- PAFD_ACCEPT_DATA AcceptData = Irp->AssociatedIrp.SystemBuffer;
+ PAFD_ACCEPT_DATA AcceptData =
+ (PAFD_ACCEPT_DATA)Irp->AssociatedIrp.SystemBuffer;
PLIST_ENTRY PendingConn;
AFD_DbgPrint(MID_TRACE,("Called\n"));
return LostSocket( Irp );
}
- for( PendingConn = FCB->PendingConnections.Flink;
+ for (PendingConn = FCB->PendingConnections.Flink;
PendingConn != &FCB->PendingConnections;
PendingConn = PendingConn->Flink )
{
AcceptData->SequenceNumber,
PendingConnObj->Seq);
- if( PendingConnObj->Seq == AcceptData->SequenceNumber )
+ if (PendingConnObj->Seq == AcceptData->SequenceNumber)
{
PFILE_OBJECT NewFileObject = NULL;
- RemoveEntryList( PendingConn );
+ RemoveEntryList(PendingConn);
Status = ObReferenceObjectByHandle( AcceptData->ListenHandle,
FILE_ALL_ACCESS,
(PVOID *)&NewFileObject,
NULL );
- if( !NT_SUCCESS(Status) )
+ if (!NT_SUCCESS(Status))
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
ASSERT(NewFileObject != FileObject);
ExFreePool( PendingConnObj );
- if( !IsListEmpty( &FCB->PendingConnections ) )
+ if (!IsListEmpty( &FCB->PendingConnections))
{
FCB->PollState |= AFD_EVENT_ACCEPT;
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
- PollReeval( FCB->DeviceExt, FCB->FileObject );
+ PollReeval(FCB->DeviceExt, FCB->FileObject);
}
else
FCB->PollState &= ~AFD_EVENT_ACCEPT;
- SocketStateUnlock( FCB );
+ SocketStateUnlock(FCB);
return Status;
}
}
}
/* Lock a method_neither request so it'll be available from DISPATCH_LEVEL */
-PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
+PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp )
+{
BOOLEAN LockFailed = FALSE;
ASSERT(!Irp->MdlAddress);
FALSE,
FALSE,
NULL );
- if( Irp->MdlAddress ) {
- _SEH2_TRY {
+ if( Irp->MdlAddress )
+ {
+ _SEH2_TRY
+ {
MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
LockFailed = TRUE;
- } _SEH2_END;
+ }
+ _SEH2_END;
- if( LockFailed ) {
- IoFreeMdl( Irp->MdlAddress );
+ if (LockFailed)
+ {
+ IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
return NULL;
}
- } else return NULL;
+ }
+ else
+ return NULL;
break;
case IRP_MJ_READ:
FALSE,
FALSE,
NULL );
- if( Irp->MdlAddress ) {
- _SEH2_TRY {
- MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+ if (Irp->MdlAddress)
+ {
+ _SEH2_TRY
+ {
+ MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
LockFailed = TRUE;
- } _SEH2_END;
+ }
+ _SEH2_END;
- if( LockFailed ) {
- IoFreeMdl( Irp->MdlAddress );
+ if (LockFailed)
+ {
+ IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
return NULL;
}
- } else return NULL;
+ }
+ else
+ return NULL;
break;
default:
return GetLockedData(Irp, IrpSp);
}
-VOID UnlockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp )
+VOID UnlockRequest(PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
ASSERT(Irp->MdlAddress);
MmUnlockPages( Irp->MdlAddress );
* treat the address buffer as an ordinary client buffer. It's only used
* for datagrams. */
-PAFD_WSABUF LockBuffers( PAFD_WSABUF Buf, UINT Count,
- PVOID AddressBuf, PINT AddressLen,
- BOOLEAN Write, BOOLEAN LockAddress ) {
+PAFD_WSABUF
+LockBuffers
+( PAFD_WSABUF Buf, UINT Count,
+ PVOID AddressBuf, PINT AddressLen,
+ BOOLEAN Write, BOOLEAN LockAddress )
+{
UINT i;
/* Copy the buffer array so we don't lose it */
UINT Lock = LockAddress ? 2 : 0;
UINT Size = sizeof(AFD_WSABUF) * (Count + Lock);
- PAFD_WSABUF NewBuf = ExAllocatePool( PagedPool, Size * 2 );
+ PAFD_WSABUF NewBuf = (PAFD_WSABUF)ExAllocatePool(PagedPool, Size * 2);
BOOLEAN LockFailed = FALSE;
PAFD_MAPBUF MapBuf;
AFD_DbgPrint(MID_TRACE,("Called(%08x)\n", NewBuf));
- if( NewBuf ) {
+ if (NewBuf)
+ {
RtlZeroMemory(NewBuf, Size * 2);
- MapBuf = (PAFD_MAPBUF)(NewBuf + Count + Lock);
+ MapBuf = (PAFD_MAPBUF)(NewBuf + Count + Lock);
- _SEH2_TRY {
- RtlCopyMemory( NewBuf, Buf, sizeof(AFD_WSABUF) * Count );
- if( LockAddress ) {
- if (AddressBuf && AddressLen) {
+ _SEH2_TRY
+ {
+ RtlCopyMemory(NewBuf, Buf, sizeof(AFD_WSABUF) * Count);
+
+ if (LockAddress)
+ {
+ if (AddressBuf && AddressLen)
+ {
NewBuf[Count].buf = AddressBuf;
NewBuf[Count].len = *AddressLen;
NewBuf[Count + 1].buf = (PVOID)AddressLen;
}
Count += 2;
}
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
AFD_DbgPrint(MIN_TRACE,("Access violation copying buffer info "
"from userland (%x %x)\n",
Buf, AddressLen));
- ExFreePool( NewBuf );
+ ExFreePool(NewBuf);
_SEH2_YIELD(return NULL);
- } _SEH2_END;
-
- for( i = 0; i < Count; i++ ) {
- AFD_DbgPrint(MID_TRACE,("Locking buffer %d (%x:%d)\n",
- i, NewBuf[i].buf, NewBuf[i].len));
-
- if( NewBuf[i].buf && NewBuf[i].len ) {
- MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
- NewBuf[i].len,
- FALSE,
- FALSE,
- NULL );
- } else {
- MapBuf[i].Mdl = NULL;
- continue;
- }
-
- AFD_DbgPrint(MID_TRACE,("NewMdl @ %x\n", MapBuf[i].Mdl));
-
- if( MapBuf[i].Mdl ) {
- AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
- _SEH2_TRY {
- MmProbeAndLockPages( MapBuf[i].Mdl, KernelMode,
- Write ? IoModifyAccess : IoReadAccess );
- } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
- LockFailed = TRUE;
- } _SEH2_END;
- AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
-
- if( LockFailed ) {
- IoFreeMdl( MapBuf[i].Mdl );
- MapBuf[i].Mdl = NULL;
- ExFreePool( NewBuf );
- return NULL;
- }
- } else {
- ExFreePool( NewBuf );
- return NULL;
+ }
+ _SEH2_END;
+
+ for (i = 0; i < Count; i++)
+ {
+ AFD_DbgPrint(MID_TRACE,("Locking buffer %d (%x:%d)\n",
+ i, NewBuf[i].buf, NewBuf[i].len));
+
+ if (NewBuf[i].buf && NewBuf[i].len)
+ {
+ MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
+ NewBuf[i].len,
+ FALSE,
+ FALSE,
+ NULL );
+ }
+ else
+ {
+ MapBuf[i].Mdl = NULL;
+ continue;
+ }
+
+ AFD_DbgPrint(MID_TRACE,("NewMdl @ %x\n", MapBuf[i].Mdl));
+
+ if (MapBuf[i].Mdl)
+ {
+ AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
+ _SEH2_TRY
+ {
+ MmProbeAndLockPages( MapBuf[i].Mdl, KernelMode,
+ Write ? IoModifyAccess : IoReadAccess );
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ LockFailed = TRUE;
+ }
+ _SEH2_END;
+
+ AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
+
+ if (LockFailed)
+ {
+ IoFreeMdl( MapBuf[i].Mdl );
+ MapBuf[i].Mdl = NULL;
+ ExFreePool( NewBuf );
+ return NULL;
+ }
+ }
+ else
+ {
+ ExFreePool( NewBuf );
+ return NULL;
+ }
}
- }
}
AFD_DbgPrint(MID_TRACE,("Leaving %x\n", NewBuf));
return NewBuf;
}
-VOID UnlockBuffers( PAFD_WSABUF Buf, UINT Count, BOOL Address ) {
+VOID UnlockBuffers(PAFD_WSABUF Buf, UINT Count, BOOL Address)
+{
UINT Lock = Address ? 2 : 0;
PAFD_MAPBUF Map = (PAFD_MAPBUF)(Buf + Count + Lock);
UINT i;
- if( !Buf ) return;
+ if (!Buf)
+ return;
- for( i = 0; i < Count + Lock; i++ ) {
- if( Map[i].Mdl ) {
- MmUnlockPages( Map[i].Mdl );
- IoFreeMdl( Map[i].Mdl );
- Map[i].Mdl = NULL;
- }
+ for (i=0; i < Count + Lock; i++)
+ {
+ if (Map[i].Mdl)
+ {
+ MmUnlockPages( Map[i].Mdl );
+ IoFreeMdl( Map[i].Mdl );
+ Map[i].Mdl = NULL;
+ }
}
- ExFreePool( Buf );
+ ExFreePool(Buf);
Buf = NULL;
}
/* Produce a kernel-land handle array with handles replaced by object
* pointers. This will allow the system to do proper alerting */
-PAFD_HANDLE LockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
+PAFD_HANDLE LockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
+{
UINT i;
NTSTATUS Status = STATUS_SUCCESS;
- PAFD_HANDLE FileObjects = ExAllocatePool
- ( NonPagedPool, HandleCount * sizeof(AFD_HANDLE) );
+ PAFD_HANDLE FileObjects =
+ (PAFD_HANDLE)ExAllocatePool(NonPagedPool, HandleCount * sizeof(AFD_HANDLE));
- for( i = 0; FileObjects && i < HandleCount; i++ ) {
- FileObjects[i].Status = 0;
- FileObjects[i].Events = HandleArray[i].Events;
+ for (i=0; FileObjects && i < HandleCount; i++)
+ {
+ FileObjects[i].Status = 0;
+ FileObjects[i].Events = HandleArray[i].Events;
FileObjects[i].Handle = 0;
- if( !HandleArray[i].Handle ) continue;
- if( NT_SUCCESS(Status) ) {
- Status = ObReferenceObjectByHandle
- ( (PVOID)HandleArray[i].Handle,
- FILE_ALL_ACCESS,
- NULL,
- KernelMode,
- (PVOID*)&FileObjects[i].Handle,
- NULL );
- }
-
- if( !NT_SUCCESS(Status) )
+
+ if (!HandleArray[i].Handle)
+ continue;
+
+ if (NT_SUCCESS(Status))
+ {
+ Status = ObReferenceObjectByHandle
+ ( (PVOID)HandleArray[i].Handle,
+ FILE_ALL_ACCESS,
+ NULL,
+ KernelMode,
+ (PVOID*)&FileObjects[i].Handle,
+ NULL );
+ }
+
+ if (!NT_SUCCESS(Status))
FileObjects[i].Handle = 0;
}
- if( !NT_SUCCESS(Status) ) {
- UnlockHandles( FileObjects, HandleCount );
- return NULL;
+ if (!NT_SUCCESS(Status))
+ {
+ UnlockHandles(FileObjects, HandleCount);
+ return NULL;
}
return FileObjects;
}
-VOID UnlockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
+VOID UnlockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
+{
UINT i;
- for( i = 0; i < HandleCount; i++ ) {
- if( HandleArray[i].Handle )
- ObDereferenceObject( (PVOID)HandleArray[i].Handle );
+ for (i = 0; i < HandleCount; i++)
+ {
+ if (HandleArray[i].Handle)
+ ObDereferenceObject( (PVOID)HandleArray[i].Handle );
}
- ExFreePool( HandleArray );
+ ExFreePool(HandleArray);
HandleArray = NULL;
}
-BOOLEAN SocketAcquireStateLock( PAFD_FCB FCB ) {
- if( !FCB ) return FALSE;
+BOOLEAN SocketAcquireStateLock(PAFD_FCB FCB)
+{
+ if (!FCB )
+ return FALSE;
return !KeWaitForMutexObject(&FCB->Mutex,
Executive,
NULL);
}
-VOID SocketStateUnlock( PAFD_FCB FCB ) {
+VOID SocketStateUnlock(PAFD_FCB FCB)
+{
KeReleaseMutex(&FCB->Mutex, FALSE);
}
-NTSTATUS NTAPI UnlockAndMaybeComplete
-( PAFD_FCB FCB, NTSTATUS Status, PIRP Irp,
- UINT Information ) {
+NTSTATUS
+NTAPI
+UnlockAndMaybeComplete
+( PAFD_FCB FCB,
+ NTSTATUS Status,
+ PIRP Irp,
+ UINT Information )
+{
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = Information;
- if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
+
+ if (Irp->MdlAddress)
+ UnlockRequest( Irp, IoGetCurrentIrpStackLocation(Irp));
+
(void)IoSetCancelRoutine(Irp, NULL);
- SocketStateUnlock( FCB );
- IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+
+ SocketStateUnlock(FCB);
+ IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
return Status;
}
-NTSTATUS LostSocket( PIRP Irp ) {
+NTSTATUS LostSocket(PIRP Irp)
+{
NTSTATUS Status = STATUS_FILE_CLOSED;
AFD_DbgPrint(MIN_TRACE,("Called.\n"));
+
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = Status;
- if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
- IoCompleteRequest( Irp, IO_NO_INCREMENT );
+
+ if (Irp->MdlAddress)
+ UnlockRequest(Irp, IoGetCurrentIrpStackLocation(Irp));
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
return Status;
}
-NTSTATUS LeaveIrpUntilLater( PAFD_FCB FCB, PIRP Irp, UINT Function ) {
+NTSTATUS LeaveIrpUntilLater(PAFD_FCB FCB, PIRP Irp, UINT Function)
+{
NTSTATUS Status;
/* Add the IRP to the queue in all cases (so AfdCancelHandler will work properly) */
* so we are to call the cancel routine ourselves right here to cancel the IRP
* (which handles all the stuff we do above) and return STATUS_CANCELLED to the caller
*/
- AfdCancelHandler(IoGetCurrentIrpStackLocation(Irp)->DeviceObject,
- Irp);
+ AfdCancelHandler(IoGetCurrentIrpStackLocation(Irp)->DeviceObject, Irp);
Status = STATUS_CANCELLED;
}
- SocketStateUnlock( FCB );
+ SocketStateUnlock(FCB);
return Status;
}
#endif /* DBG */
-void OskitDumpBuffer( PCHAR Data, UINT Len )
-{
- unsigned int i;
-
- for( i = 0; i < Len; i++ )
- {
- if( i && !(i & 0xf) )
- DbgPrint( "\n" );
- if( !(i & 0xf) )
- DbgPrint( "%08x: ", (UINT)(Data + i) );
- DbgPrint( " %02x", Data[i] & 0xff );
- }
- DbgPrint("\n");
-}
-
/* FUNCTIONS */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath);
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdGetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (FCB->DisconnectOptionsSize == 0)
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
PVOID DisconnectOptions = LockRequest(Irp, IrpSp);
UINT DisconnectOptionsSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!DisconnectOptions)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
PUINT DisconnectOptionsSize = (PUINT)LockRequest(Irp, IrpSp);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!DisconnectOptionsSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
AfdGetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (FCB->DisconnectDataSize == 0)
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
ASSERT(FCB->DisconnectData);
- if (FCB->FilledDisconnectData < BufferSize) BufferSize = FCB->FilledDisconnectData;
+ if (FCB->FilledDisconnectData < BufferSize)
+ BufferSize = FCB->FilledDisconnectData;
RtlCopyMemory(Irp->UserBuffer,
FCB->DisconnectData,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PVOID DisconnectData = LockRequest(Irp, IrpSp);
UINT DisconnectDataSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!DisconnectData)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
- PUINT DisconnectDataSize = LockRequest(Irp, IrpSp);
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
+ PUINT DisconnectDataSize = (PUINT)LockRequest(Irp, IrpSp);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
if (!DisconnectDataSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
-static NTSTATUS NTAPI
+static
+NTSTATUS
+NTAPI
AfdGetTdiHandles(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
- PULONG HandleFlags = LockRequest(Irp, IrpSp);
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
+ PULONG HandleFlags = (PULONG)LockRequest(Irp, IrpSp);
PAFD_TDI_HANDLE_DATA HandleData = Irp->UserBuffer;
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
-static NTSTATUS NTAPI
+static
+NTSTATUS
+NTAPI
AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
EaInfo = Irp->AssociatedIrp.SystemBuffer;
- if( EaInfo )
+ if (EaInfo)
{
ConnectInfo = (PAFD_CREATE_PACKET)(EaInfo->EaName + EaInfo->EaNameLength + 1);
EaInfoValue = (PWCHAR)(((PCHAR)ConnectInfo) + sizeof(AFD_CREATE_PACKET));
AFD_DbgPrint(MID_TRACE,("About to allocate the new FCB\n"));
- FCB = ExAllocatePool(NonPagedPool, sizeof(AFD_FCB));
+ FCB = (PAFD_FCB)ExAllocatePool(NonPagedPool, sizeof(AFD_FCB));
RtlZeroMemory(FCB, sizeof(AFD_FCB));
- if( FCB == NULL )
+ if (FCB == NULL)
{
Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NO_MEMORY;
}
- AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %x (FileObject %x Flags %x)\n", FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
+ AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %x (FileObject %x Flags %x)\n",
+ FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
RtlZeroMemory( FCB, sizeof( *FCB ) );
FCB->AddressFile.Handle = INVALID_HANDLE_VALUE;
FCB->Connection.Handle = INVALID_HANDLE_VALUE;
- KeInitializeMutex( &FCB->Mutex, 0 );
+ KeInitializeMutex(&FCB->Mutex, 0);
- for( i = 0; i < MAX_FUNCTIONS; i++ )
+ for (i=0; i < MAX_FUNCTIONS; i++)
{
- InitializeListHead( &FCB->PendingIrpList[i] );
+ InitializeListHead(&FCB->PendingIrpList[i]);
}
- InitializeListHead( &FCB->DatagramList );
- InitializeListHead( &FCB->PendingConnections );
+ InitializeListHead(&FCB->DatagramList);
+ InitializeListHead(&FCB->PendingConnections);
AFD_DbgPrint(MID_TRACE,("%x: Checking command channel\n", FCB));
- if( ConnectInfo )
+ if (ConnectInfo)
{
FCB->TdiDeviceName.Length = ConnectInfo->SizeOfTransportName;
FCB->TdiDeviceName.MaximumLength = FCB->TdiDeviceName.Length;
- FCB->TdiDeviceName.Buffer =
- ExAllocatePool( NonPagedPool, FCB->TdiDeviceName.Length );
+ FCB->TdiDeviceName.Buffer = ExAllocatePool(NonPagedPool, FCB->TdiDeviceName.Length);
+
RtlZeroMemory(FCB->TdiDeviceName.Buffer, FCB->TdiDeviceName.Length);
- if( !FCB->TdiDeviceName.Buffer )
+ if (!FCB->TdiDeviceName.Buffer)
{
ExFreePool(FCB);
AFD_DbgPrint(MID_TRACE,("Could not copy target string\n"));
Irp->IoStatus.Status = STATUS_NO_MEMORY;
- IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+
+ IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
return STATUS_NO_MEMORY;
}
FileObject->FsContext = FCB;
/* It seems that UDP sockets are writable from inception */
- if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
+ if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
{
AFD_DbgPrint(MID_TRACE,("Packet oriented socket\n"));
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
- if( !NT_SUCCESS(Status) )
+ if (!NT_SUCCESS(Status))
{
- if( FCB->TdiDeviceName.Buffer )
- ExFreePool( FCB->TdiDeviceName.Buffer );
- ExFreePool( FCB );
+ if (FCB->TdiDeviceName.Buffer)
+ ExFreePool( FCB->TdiDeviceName.Buffer);
+ ExFreePool(FCB);
FileObject->FsContext = NULL;
}
return Status;
}
-static NTSTATUS NTAPI
-AfdCleanupSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+static
+NTSTATUS
+NTAPI
+AfdCleanupSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
DbgPrint("[AFD, AfdCleanupSocket] Called\n");
- if ( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return LostSocket(Irp);
for (Function = 0; Function < MAX_FUNCTIONS; Function++)
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
-static NTSTATUS NTAPI
+static
+NTSTATUS
+NTAPI
AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
PLIST_ENTRY QeltEntry;
- AFD_DbgPrint(MID_TRACE,
- ("AfdClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp));
+ AFD_DbgPrint(MID_TRACE, ("AfdClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp));
DbgPrint("[AFD, AfdCloseSocket] Called\n");
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
DbgPrint("[AFD, AfdCloseSocket] Setting closed state\n");
DbgPrint("[AFD, AfdCloseSocket] Canceling in flight requests (AFD -> tcpip)\n");
/* Cancel our pending _In Flight_ IRPs
That is IRPs from AFD -> tcpip*/
- for( i = 0; i < IN_FLIGHT_REQUESTS; i++ )
+ for (i=0; i < IN_FLIGHT_REQUESTS; i++)
{
- if( InFlightRequest[i]->InFlightRequest )
+ if (InFlightRequest[i]->InFlightRequest)
{
AFD_DbgPrint(MID_TRACE,("Cancelling in flight irp %d (%x)\n",
i, InFlightRequest[i]->InFlightRequest));
DbgPrint("[AFD, AfdCloseSocket] Doing final cleanups\n");
- SocketStateUnlock( FCB );
+ SocketStateUnlock(FCB);
- if( FCB->EventSelect )
- ObDereferenceObject( FCB->EventSelect );
+ if (FCB->EventSelect)
+ ObDereferenceObject(FCB->EventSelect);
- if( FCB->Context )
- ExFreePool( FCB->Context );
+ if (FCB->Context)
+ ExFreePool(FCB->Context);
- if( FCB->Recv.Window )
- ExFreePool( FCB->Recv.Window );
+ if (FCB->Recv.Window)
+ ExFreePool(FCB->Recv.Window);
- if( FCB->Send.Window )
- ExFreePool( FCB->Send.Window );
+ if (FCB->Send.Window)
+ ExFreePool(FCB->Send.Window);
- if( FCB->AddressFrom )
- ExFreePool( FCB->AddressFrom );
+ if ( FCB->AddressFrom )
+ ExFreePool(FCB->AddressFrom);
- if( FCB->ConnectInfo )
- ExFreePool( FCB->ConnectInfo );
+ if (FCB->ConnectInfo)
+ ExFreePool(FCB->ConnectInfo);
- if( FCB->ConnectData )
- ExFreePool( FCB->ConnectData );
+ if (FCB->ConnectData)
+ ExFreePool(FCB->ConnectData);
- if( FCB->DisconnectData )
- ExFreePool( FCB->DisconnectData );
+ if (FCB->DisconnectData)
+ ExFreePool(FCB->DisconnectData);
- if( FCB->ConnectOptions )
- ExFreePool( FCB->ConnectOptions );
+ if (FCB->ConnectOptions)
+ ExFreePool(FCB->ConnectOptions);
- if( FCB->DisconnectOptions )
- ExFreePool( FCB->DisconnectOptions );
+ if (FCB->DisconnectOptions)
+ ExFreePool(FCB->DisconnectOptions);
- if( FCB->LocalAddress )
- ExFreePool( FCB->LocalAddress );
+ if (FCB->LocalAddress)
+ ExFreePool(FCB->LocalAddress);
- if( FCB->RemoteAddress )
- ExFreePool( FCB->RemoteAddress );
+ if (FCB->RemoteAddress)
+ ExFreePool(FCB->RemoteAddress);
- if( FCB->Connection.Object )
+ if (FCB->Connection.Object)
{
TdiDisassociateAddressFile(FCB->Connection.Object);
ObDereferenceObject(FCB->Connection.Object);
}
- if( FCB->AddressFile.Object )
+ if (FCB->AddressFile.Object)
ObDereferenceObject(FCB->AddressFile.Object);
DbgPrint("[AFD, AfdCloseSocket] Closing FCB->AddressFile.Handle\n");
- if( FCB->AddressFile.Handle != INVALID_HANDLE_VALUE )
+ if (FCB->AddressFile.Handle != INVALID_HANDLE_VALUE)
{
if (ZwClose(FCB->AddressFile.Handle) == STATUS_INVALID_HANDLE)
{
DbgPrint("[AFD, AfdCloseSocket] Closing FCB->Connection.Handle\n");
- if( FCB->Connection.Handle != INVALID_HANDLE_VALUE )
+ if (FCB->Connection.Handle != INVALID_HANDLE_VALUE)
{
if (ZwClose(FCB->Connection.Handle) == STATUS_INVALID_HANDLE)
{
DbgPrint("[AFD, AfdCloseSocket] Freeing FCB->TdiDeviceName.Buffer\n");
- if( FCB->TdiDeviceName.Buffer )
+ if (FCB->TdiDeviceName.Buffer)
ExFreePool(FCB->TdiDeviceName.Buffer);
DbgPrint("[AFD, AfdCloseSocket] Freeing FCB\n");
return STATUS_SUCCESS;
}
-static NTSTATUS NTAPI
-AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+static
+NTSTATUS
+NTAPI
+AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_DISCONNECT_INFO DisReq;
IO_STATUS_BLOCK Iosb;
PTDI_CONNECTION_INFORMATION ConnectionReturnInfo;
NTSTATUS Status = STATUS_SUCCESS;
USHORT Flags = 0;
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
- if( !(DisReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
- Irp, 0 );
+ if (!(DisReq = LockRequest(Irp, IrpSp)))
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
- if( DisReq->DisconnectType & AFD_DISCONNECT_SEND )
+ if ( DisReq->DisconnectType & AFD_DISCONNECT_SEND)
Flags |= TDI_DISCONNECT_RELEASE;
- if( DisReq->DisconnectType & AFD_DISCONNECT_RECV ||
- DisReq->DisconnectType & AFD_DISCONNECT_ABORT )
+ if ( DisReq->DisconnectType & AFD_DISCONNECT_RECV ||
+ DisReq->DisconnectType & AFD_DISCONNECT_ABORT)
Flags |= TDI_DISCONNECT_ABORT;
if (!(FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS))
{
- if( !FCB->ConnectInfo )
- return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
- Irp, 0 );
+ if (!FCB->ConnectInfo)
+ return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
ASSERT(FCB->RemoteAddress);
Status = TdiBuildNullConnectionInfo
( &ConnectionReturnInfo, FCB->RemoteAddress->Address[0].AddressType );
- if( !NT_SUCCESS(Status) )
- return UnlockAndMaybeComplete( FCB, Status,
- Irp, 0 );
+ if (!NT_SUCCESS(Status))
+ return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
FCB->ConnectInfo->UserData = FCB->DisconnectData;
FCB->ConnectInfo->UserDataLength = FCB->DisconnectDataSize;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
-static NTSTATUS NTAPI
+static
+NTSTATUS
+NTAPI
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
AFD_DbgPrint(MID_TRACE,("AfdDispatch: %d\n", IrpSp->MajorFunction));
- if( IrpSp->MajorFunction != IRP_MJ_CREATE)
+ if (IrpSp->MajorFunction != IRP_MJ_CREATE)
{
AFD_DbgPrint(MID_TRACE,("FO %x, IrpSp->FO %x\n",
FileObject, IrpSp->FileObject));
if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV ||
IrpSp->MajorFunction == IRP_MJ_READ)
{
- RecvReq = GetLockedData(Irp, IrpSp);
+ RecvReq = (PAFD_RECV_INFO)GetLockedData(Irp, IrpSp);
UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
}
else if ((IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND ||
}
else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SELECT)
{
- PollReq = Irp->AssociatedIrp.SystemBuffer;
+ PollReq = (PAFD_POLL_INFO)Irp->AssociatedIrp.SystemBuffer;
ZeroEvents(PollReq->Handles, PollReq->HandleCount);
SignalSocket(Poll, NULL, PollReq, STATUS_CANCELLED);
}
}
-VOID NTAPI
+VOID
+NTAPI
AfdCancelHandler(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
ULONG Function, IoctlCode;
PIRP CurrentIrp;
PLIST_ENTRY CurrentEntry;
{
case IOCTL_AFD_RECV:
case IOCTL_AFD_RECV_DATAGRAM:
- Function = FUNCTION_RECV;
- break;
+ Function = FUNCTION_RECV;
+ break;
case IOCTL_AFD_SEND:
case IOCTL_AFD_SEND_DATAGRAM:
- Function = FUNCTION_SEND;
- break;
+ Function = FUNCTION_SEND;
+ break;
case IOCTL_AFD_CONNECT:
- Function = FUNCTION_CONNECT;
- break;
+ Function = FUNCTION_CONNECT;
+ break;
case IOCTL_AFD_WAIT_FOR_LISTEN:
- Function = FUNCTION_PREACCEPT;
- break;
+ Function = FUNCTION_PREACCEPT;
+ break;
case IOCTL_AFD_SELECT:
- KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
+ KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
CurrentEntry = DeviceExt->Polls.Flink;
while (CurrentEntry != &DeviceExt->Polls)
DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (Function: %d)\n", Function);
}
-static VOID NTAPI
+static
+VOID
+NTAPI
AfdUnload(PDRIVER_OBJECT DriverObject)
{
}
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
DriverObject->DriverUnload = AfdUnload;
- Status = IoCreateDevice
- ( DriverObject,
- sizeof(AFD_DEVICE_EXTENSION),
- &wstrDeviceName,
- FILE_DEVICE_NAMED_PIPE,
- 0,
- FALSE,
- &DeviceObject );
+ Status = IoCreateDevice(DriverObject,
+ sizeof(AFD_DEVICE_EXTENSION),
+ &wstrDeviceName,
+ FILE_DEVICE_NAMED_PIPE,
+ 0,
+ FALSE,
+ &DeviceObject );
/* failure */
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
- return (Status);
+ return (Status);
}
DeviceExt = DeviceObject->DeviceExtension;
#include "tdiconn.h"
#include "debug.h"
-static VOID HandleEOFOnIrp( PAFD_FCB FCB, NTSTATUS Status, ULONG_PTR Information )
+static VOID HandleEOFOnIrp(PAFD_FCB FCB, NTSTATUS Status, ULONG_PTR Information)
{
- if( ( Status == STATUS_SUCCESS && !Information ) ||
- ( !NT_SUCCESS( Status ) ) )
+ if ((Status == STATUS_SUCCESS && !Information) || (!NT_SUCCESS(Status)))
{
/* The socket has been closed */
FCB->PollState |= AFD_EVENT_CLOSE;
}
}
-static BOOLEAN CantReadMore( PAFD_FCB FCB ) {
+static BOOLEAN CantReadMore( PAFD_FCB FCB )
+{
UINT BytesAvailable = FCB->Recv.Content - FCB->Recv.BytesUsed;
return !BytesAvailable &&
(FCB->PollState & (AFD_EVENT_CLOSE | AFD_EVENT_ABORT));
}
-static VOID RefillSocketBuffer( PAFD_FCB FCB ) {
+static VOID RefillSocketBuffer( PAFD_FCB FCB )
+{
NTSTATUS Status;
- if( !FCB->ReceiveIrp.InFlightRequest &&
- !(FCB->PollState & (AFD_EVENT_CLOSE | AFD_EVENT_ABORT)) ) {
+ if (!FCB->ReceiveIrp.InFlightRequest &&
+ !(FCB->PollState & (AFD_EVENT_CLOSE | AFD_EVENT_ABORT)))
+ {
AFD_DbgPrint(MID_TRACE,("Replenishing buffer\n"));
Status = TdiReceive( &FCB->ReceiveIrp.InFlightRequest,
}
}
-static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
- PAFD_RECV_INFO RecvReq,
- PUINT TotalBytesCopied ) {
+static
+NTSTATUS
+TryToSatisfyRecvRequestFromBuffer
+( PAFD_FCB FCB,
+ PAFD_RECV_INFO RecvReq,
+ PUINT TotalBytesCopied )
+{
UINT i, BytesToCopy = 0, FcbBytesCopied = FCB->Recv.BytesUsed,
BytesAvailable =
FCB->Recv.Content - FCB->Recv.BytesUsed;
AFD_DbgPrint(MID_TRACE,("Called, BytesAvailable = %d\n",
BytesAvailable));
- if( CantReadMore(FCB) ) return STATUS_SUCCESS;
- if( !BytesAvailable ) return STATUS_PENDING;
+ if (CantReadMore(FCB))
+ return STATUS_SUCCESS;
+ if (!BytesAvailable)
+ return STATUS_PENDING;
Map = (PAFD_MAPBUF)(RecvReq->BufferArray + RecvReq->BufferCount);
AFD_DbgPrint(MID_TRACE,("Buffer Count: %d @ %x\n",
RecvReq->BufferCount,
RecvReq->BufferArray));
- for( i = 0;
- RecvReq->BufferArray &&
- BytesAvailable &&
- i < RecvReq->BufferCount;
- i++ ) {
- BytesToCopy =
- MIN( RecvReq->BufferArray[i].len, BytesAvailable );
-
- if( Map[i].Mdl ) {
+ for (i = 0;
+ RecvReq->BufferArray && BytesAvailable && i < RecvReq->BufferCount;
+ i++)
+ {
+ BytesToCopy = MIN(RecvReq->BufferArray[i].len, BytesAvailable);
+
+ if (Map[i].Mdl)
+ {
Map[i].BufferAddress = MmMapLockedPages( Map[i].Mdl, KernelMode );
AFD_DbgPrint(MID_TRACE,("Buffer %d: %x:%d\n",
}
/* If there's nothing left in our buffer start a new request */
- if( FCB->Recv.BytesUsed == FCB->Recv.Content ) {
+ if ( FCB->Recv.BytesUsed == FCB->Recv.Content )
+ {
FCB->Recv.BytesUsed = FCB->Recv.Content = 0;
FCB->PollState &= ~AFD_EVENT_RECEIVE;
return STATUS_SUCCESS;
}
-static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
+static
+NTSTATUS
+ReceiveActivity(PAFD_FCB FCB, PIRP Irp)
+{
PLIST_ENTRY NextIrpEntry;
PIRP NextIrp;
PIO_STACK_LOCATION NextIrpSp;
AFD_DbgPrint(MID_TRACE,("FCB %x Receive data waiting %d\n",
FCB, FCB->Recv.Content));
- if( CantReadMore( FCB ) ) {
+ if (CantReadMore(FCB))
+ {
/* Success here means that we got an EOF. Complete a pending read
* with zero bytes if we haven't yet overread, then kill the others.
*/
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) {
- NextIrpEntry =
- RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
- NextIrp =
- CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp);
RecvReq = GetLockedData(NextIrp, NextIrpSp);
AFD_DbgPrint(MID_TRACE,("Completing recv %x (%d)\n", NextIrp,
TotalBytesCopied));
- UnlockBuffers( RecvReq->BufferArray,
- RecvReq->BufferCount, FALSE );
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
+
Status = NextIrp->IoStatus.Status =
- FCB->Overread ? STATUS_END_OF_FILE : STATUS_SUCCESS;
+ FCB->Overread ? STATUS_END_OF_FILE : STATUS_SUCCESS;
NextIrp->IoStatus.Information = 0;
- if( NextIrp == Irp ) RetStatus = Status;
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
+
+ if (NextIrp == Irp)
+ RetStatus = Status;
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
FCB->Overread = TRUE;
}
- } else {
+ }
+ else
+ {
/* Kick the user that receive would be possible now */
/* XXX Not implemented yet */
/*OskitDumpBuffer( FCB->Recv.Window, FCB->Recv.Content );*/
/* Try to clear some requests */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) {
- NextIrpEntry =
- RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
- NextIrp =
- CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp);
RecvReq = GetLockedData(NextIrp, NextIrpSp);
AFD_DbgPrint(MID_TRACE,("RecvReq @ %x\n", RecvReq));
- Status = TryToSatisfyRecvRequestFromBuffer
- ( FCB, RecvReq, &TotalBytesCopied );
+ Status = TryToSatisfyRecvRequestFromBuffer(FCB, RecvReq, &TotalBytesCopied);
- if( Status == STATUS_PENDING ) {
+ if (Status == STATUS_PENDING)
+ {
AFD_DbgPrint(MID_TRACE,("Ran out of data for %x\n", NextIrp));
InsertHeadList(&FCB->PendingIrpList[FUNCTION_RECV],
&NextIrp->Tail.Overlay.ListEntry);
break;
- } else {
+ }
+ else
+ {
AFD_DbgPrint(MID_TRACE,("Completing recv %x (%d)\n", NextIrp,
TotalBytesCopied));
UnlockBuffers( RecvReq->BufferArray,
RecvReq->BufferCount, FALSE );
NextIrp->IoStatus.Status = Status;
NextIrp->IoStatus.Information = TotalBytesCopied;
- if( NextIrp == Irp ) {
+
+ if (NextIrp == Irp)
+ {
RetStatus = Status;
RetBytesCopied = TotalBytesCopied;
}
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
}
}
if( FCB->Recv.Content - FCB->Recv.BytesUsed &&
- IsListEmpty(&FCB->PendingIrpList[FUNCTION_RECV]) ) {
+ IsListEmpty(&FCB->PendingIrpList[FUNCTION_RECV]) )
+ {
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
- } else
+ }
+ else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
AFD_DbgPrint(MID_TRACE,("RetStatus for irp %x is %x\n", Irp, RetStatus));
/* Sometimes we're called with a NULL Irp */
- if( Irp ) {
+ if (Irp)
+ {
Irp->IoStatus.Status = RetStatus;
Irp->IoStatus.Information = RetBytesCopied;
}
return RetStatus;
}
-NTSTATUS NTAPI ReceiveComplete
+NTSTATUS
+NTAPI
+ReceiveComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
- PVOID Context ) {
+ PVOID Context )
+{
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
PIRP NextIrp;
AFD_DbgPrint(MID_TRACE,("Called\n"));
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
ASSERT(FCB->ReceiveIrp.InFlightRequest == Irp);
FCB->Recv.Content = Irp->IoStatus.Information;
FCB->Recv.BytesUsed = 0;
- if( FCB->State == SOCKET_STATE_CLOSED ) {
+ if (FCB->State == SOCKET_STATE_CLOSED)
+ {
AFD_DbgPrint(MIN_TRACE,("!!! CLOSING SOCK GOT A RECEIVE COMPLETE !!!\n"));
+
/* Cleanup our IRP queue because the FCB is being destroyed */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) {
- NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
- NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp);
- RecvReq = GetLockedData(NextIrp, NextIrpSp);
- NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
- NextIrp->IoStatus.Information = 0;
- UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
- IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp);
+ RecvReq = GetLockedData(NextIrp, NextIrpSp);
+ NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
+ NextIrp->IoStatus.Information = 0;
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
+
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
+ IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
- SocketStateUnlock( FCB );
- return STATUS_FILE_CLOSED;
- } else if( FCB->State == SOCKET_STATE_LISTENING ) {
+
+ SocketStateUnlock( FCB );
+ return STATUS_FILE_CLOSED;
+ }
+ else if (FCB->State == SOCKET_STATE_LISTENING)
+ {
AFD_DbgPrint(MIN_TRACE,("!!! LISTENER GOT A RECEIVE COMPLETE !!!\n"));
SocketStateUnlock( FCB );
return STATUS_INVALID_PARAMETER;
return STATUS_SUCCESS;
}
-NTSTATUS NTAPI
-AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp, BOOLEAN Short) {
+NTSTATUS
+NTAPI
+AfdConnectedSocketReadData
+( PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PIO_STACK_LOCATION IrpSp,
+ BOOLEAN Short )
+{
NTSTATUS Status = STATUS_INVALID_PARAMETER;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_RECV_INFO RecvReq;
UINT TotalBytesCopied = 0;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
- if( FCB->State != SOCKET_STATE_CONNECTED &&
- FCB->State != SOCKET_STATE_CONNECTING ) {
+ if (FCB->State != SOCKET_STATE_CONNECTED && FCB->State != SOCKET_STATE_CONNECTING)
+ {
AFD_DbgPrint(MID_TRACE,("Called recv on wrong kind of socket (s%x)\n",
FCB->State));
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
Irp, 0 );
}
- if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
+ if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
{
AFD_DbgPrint(MID_TRACE,("Receive on connection-less sockets not implemented\n"));
- return UnlockAndMaybeComplete( FCB, STATUS_NOT_IMPLEMENTED,
- Irp, 0 );
+ return UnlockAndMaybeComplete(FCB, STATUS_NOT_IMPLEMENTED, Irp, 0);
}
- if( !(RecvReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
- Irp, 0 );
+ if (!(RecvReq = LockRequest(Irp, IrpSp)))
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
NULL, NULL,
TRUE, FALSE );
- if( !RecvReq->BufferArray ) {
- return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
- Irp, 0 );
+ if (!RecvReq->BufferArray)
+ {
+ return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
}
Irp->IoStatus.Status = STATUS_PENDING;
Status = ReceiveActivity( FCB, Irp );
- if( Status == STATUS_PENDING && (RecvReq->AfdFlags & AFD_IMMEDIATE) ) {
+ if (Status == STATUS_PENDING && (RecvReq->AfdFlags & AFD_IMMEDIATE))
+ {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
Status = STATUS_CANT_WAIT;
TotalBytesCopied = 0;
RemoveEntryList( &Irp->Tail.Overlay.ListEntry );
- UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, FALSE );
- return UnlockAndMaybeComplete( FCB, Status, Irp,
- TotalBytesCopied );
- } else if( Status == STATUS_PENDING ) {
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
+ return UnlockAndMaybeComplete( FCB, Status, Irp, TotalBytesCopied);
+ }
+ else if (Status == STATUS_PENDING)
+ {
AFD_DbgPrint(MID_TRACE,("Leaving read irp\n"));
IoMarkIrpPending( Irp );
(void)IoSetCancelRoutine(Irp, AfdCancelHandler);
- } else {
+ }
+ else
+ {
AFD_DbgPrint(MID_TRACE,("Completed with status %x\n", Status));
}
}
-static NTSTATUS NTAPI
-SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
- PAFD_STORED_DATAGRAM DatagramRecv,
- PUINT TotalBytesCopied ) {
+static
+NTSTATUS
+NTAPI
+SatisfyPacketRecvRequest
+( PAFD_FCB FCB, PIRP Irp,
+ PAFD_STORED_DATAGRAM DatagramRecv,
+ PUINT TotalBytesCopied )
+{
NTSTATUS Status = STATUS_SUCCESS;
- PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( Irp );
- PAFD_RECV_INFO RecvReq =
- GetLockedData(Irp, IrpSp);
+ PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
+ PAFD_RECV_INFO RecvReq = (PAFD_RECV_INFO)GetLockedData(Irp, IrpSp);
UINT BytesToCopy = 0, BytesAvailable = DatagramRecv->Len, AddrLen = 0;
PAFD_MAPBUF Map;
RecvReq->BufferCount +
EXTRA_LOCK_BUFFERS);
- BytesToCopy =
- MIN( RecvReq->BufferArray[0].len, BytesAvailable );
+ BytesToCopy = MIN(RecvReq->BufferArray[0].len, BytesAvailable);
AFD_DbgPrint(MID_TRACE,("BytesToCopy: %d len %d\n", BytesToCopy,
RecvReq->BufferArray[0].len));
- if( Map[0].Mdl ) {
+ if (Map[0].Mdl)
+ {
/* Copy the address */
- if( Map[1].Mdl && Map[2].Mdl ) {
+ if (Map[1].Mdl && Map[2].Mdl)
+ {
AFD_DbgPrint(MID_TRACE,("Checking TAAddressCount\n"));
- if( DatagramRecv->Address->TAAddressCount != 1 ) {
+ if (DatagramRecv->Address->TAAddressCount != 1)
+ {
AFD_DbgPrint
(MID_TRACE,
("Wierd address count %d\n",
return Status;
}
-NTSTATUS NTAPI
-PacketSocketRecvComplete(
- PDEVICE_OBJECT DeviceObject,
+NTSTATUS
+NTAPI
+PacketSocketRecvComplete
+( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
- PVOID Context ) {
+ PVOID Context )
+{
NTSTATUS Status = STATUS_SUCCESS;
- PAFD_FCB FCB = Context;
+ PAFD_FCB FCB = (PAFD_FCB)Context;
PIRP NextIrp;
PIO_STACK_LOCATION NextIrpSp;
PLIST_ENTRY ListEntry;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
ASSERT(FCB->ReceiveIrp.InFlightRequest == Irp);
FCB->ReceiveIrp.InFlightRequest = NULL;
- if( FCB->State == SOCKET_STATE_CLOSED ) {
+ if ( FCB->State == SOCKET_STATE_CLOSED )
+ {
/* Cleanup our IRP queue because the FCB is being destroyed */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) {
- NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
- NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
- RecvReq = GetLockedData(NextIrp, NextIrpSp);
- NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
- NextIrp->IoStatus.Information = 0;
- UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
- IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
+ while ( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
+ RecvReq = GetLockedData(NextIrp, NextIrpSp);
+ NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
+ NextIrp->IoStatus.Information = 0;
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
+
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation(NextIrp));
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
+ IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
/* Free all items on the datagram list */
- while( !IsListEmpty( &FCB->DatagramList ) ) {
- DatagramRecvEntry = RemoveHeadList(&FCB->DatagramList);
- DatagramRecv = CONTAINING_RECORD(DatagramRecvEntry, AFD_STORED_DATAGRAM, ListEntry);
- ExFreePool( DatagramRecv->Address );
- ExFreePool( DatagramRecv );
+ while (!IsListEmpty(&FCB->DatagramList))
+ {
+ DatagramRecvEntry = RemoveHeadList(&FCB->DatagramList);
+ DatagramRecv = CONTAINING_RECORD(DatagramRecvEntry, AFD_STORED_DATAGRAM, ListEntry);
+ ExFreePool( DatagramRecv->Address );
+ ExFreePool( DatagramRecv );
}
- SocketStateUnlock( FCB );
- return STATUS_FILE_CLOSED;
+ SocketStateUnlock(FCB);
+ return STATUS_FILE_CLOSED;
}
if (Irp->IoStatus.Status != STATUS_SUCCESS)
DatagramRecv = ExAllocatePool( NonPagedPool, DGSize );
- if( DatagramRecv ) {
+ if (DatagramRecv)
+ {
DatagramRecv->Len = Irp->IoStatus.Information;
RtlCopyMemory( DatagramRecv->Buffer, FCB->Recv.Window,
DatagramRecv->Len );
DatagramRecv->Address =
TaCopyTransportAddress( FCB->AddressFrom->RemoteAddress );
- if( !DatagramRecv->Address ) Status = STATUS_NO_MEMORY;
+ if (!DatagramRecv->Address)
+ Status = STATUS_NO_MEMORY;
- } else Status = STATUS_NO_MEMORY;
+ }
+ else Status = STATUS_NO_MEMORY;
- if( !NT_SUCCESS( Status ) ) {
- if( DatagramRecv ) ExFreePool( DatagramRecv );
- SocketStateUnlock( FCB );
+ if (!NT_SUCCESS(Status))
+ {
+ if (DatagramRecv)
+ ExFreePool(DatagramRecv);
+ SocketStateUnlock(FCB);
return Status;
- } else {
+ }
+ else
+ {
InsertTailList( &FCB->DatagramList, &DatagramRecv->ListEntry );
}
/* Satisfy as many requests as we can */
while( !IsListEmpty( &FCB->DatagramList ) &&
- !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) ) {
+ !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV] ) )
+ {
AFD_DbgPrint(MID_TRACE,("Looping trying to satisfy request\n"));
ListEntry = RemoveHeadList( &FCB->DatagramList );
DatagramRecv = CONTAINING_RECORD( ListEntry, AFD_STORED_DATAGRAM,
AFD_DbgPrint(MID_TRACE,("RecvReq: %x, DatagramRecv: %x\n",
RecvReq, DatagramRecv));
- if( DatagramRecv->Len > RecvReq->BufferArray[0].len &&
- !(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL) ) {
+ if (DatagramRecv->Len > RecvReq->BufferArray[0].len &&
+ !(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL))
+ {
InsertHeadList( &FCB->DatagramList,
&DatagramRecv->ListEntry );
Status = NextIrp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
if ( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
- } else {
+ }
+ else
+ {
AFD_DbgPrint(MID_TRACE,("Satisfying\n"));
Status = SatisfyPacketRecvRequest
( FCB, NextIrp, DatagramRecv,
InsertHeadList(&FCB->DatagramList,
&DatagramRecv->ListEntry);
}
- AFD_DbgPrint(MID_TRACE,("Unlocking\n"));
+
+ AFD_DbgPrint(MID_TRACE,("Unlocking\n"));
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
- if ( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
AFD_DbgPrint(MID_TRACE,("Completing\n"));
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
}
- if( !IsListEmpty( &FCB->DatagramList ) && IsListEmpty(&FCB->PendingIrpList[FUNCTION_RECV]) ) {
+ if (!IsListEmpty( &FCB->DatagramList ) && IsListEmpty(&FCB->PendingIrpList[FUNCTION_RECV]))
+ {
AFD_DbgPrint(MID_TRACE,("Signalling\n"));
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
- } else
+ }
+ else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
- if( NT_SUCCESS(Irp->IoStatus.Status) ) {
+ if (NT_SUCCESS(Irp->IoStatus.Status))
+ {
/* Now relaunch the datagram request */
Status = TdiReceiveDatagram
( &FCB->ReceiveIrp.InFlightRequest,
return STATUS_SUCCESS;
}
-NTSTATUS NTAPI
-AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdPacketSocketReadData
+( PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PIO_STACK_LOCATION IrpSp )
+{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_RECV_INFO_UDP RecvReq;
PLIST_ENTRY ListEntry;
PAFD_STORED_DATAGRAM DatagramRecv;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
/* Check that the socket is bound */
- if( FCB->State != SOCKET_STATE_BOUND )
+ if (FCB->State != SOCKET_STATE_BOUND)
return UnlockAndMaybeComplete
( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
- if( !(RecvReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete
- ( FCB, STATUS_NO_MEMORY, Irp, 0 );
+ if ( !(RecvReq = LockRequest(Irp, IrpSp)))
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
RecvReq->AddressLength,
TRUE, TRUE );
- if( !RecvReq->BufferArray ) { /* access violation in userspace */
- return UnlockAndMaybeComplete
- ( FCB, STATUS_ACCESS_VIOLATION, Irp, 0 );
+ if (!RecvReq->BufferArray)
+ {
+ /* access violation in userspace */
+ return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
}
- if( !IsListEmpty( &FCB->DatagramList ) ) {
+ if ( !IsListEmpty(&FCB->DatagramList))
+ {
ListEntry = RemoveHeadList( &FCB->DatagramList );
- DatagramRecv = CONTAINING_RECORD
- ( ListEntry, AFD_STORED_DATAGRAM, ListEntry );
+ DatagramRecv = CONTAINING_RECORD(ListEntry, AFD_STORED_DATAGRAM, ListEntry);
if( DatagramRecv->Len > RecvReq->BufferArray[0].len &&
- !(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL) ) {
+ !(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL) )
+ {
InsertHeadList( &FCB->DatagramList,
&DatagramRecv->ListEntry );
Status = Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
Irp->IoStatus.Information = DatagramRecv->Len;
- if( !IsListEmpty( &FCB->DatagramList ) ) {
+ if ( !IsListEmpty(&FCB->DatagramList))
+ {
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
- } else
+ }
+ else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
- return UnlockAndMaybeComplete
- ( FCB, Status, Irp, Irp->IoStatus.Information );
- } else {
- Status = SatisfyPacketRecvRequest
- ( FCB, Irp, DatagramRecv,
- (PUINT)&Irp->IoStatus.Information );
+ return UnlockAndMaybeComplete(FCB, Status, Irp, Irp->IoStatus.Information);
+ }
+ else
+ {
+ Status = SatisfyPacketRecvRequest(
+ FCB, Irp, DatagramRecv,
+ (PUINT)&Irp->IoStatus.Information);
if (RecvReq->TdiFlags & TDI_RECEIVE_PEEK)
{
&DatagramRecv->ListEntry);
}
- if( !IsListEmpty( &FCB->DatagramList ) ) {
+ if (!IsListEmpty(&FCB->DatagramList))
+ {
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
- } else
+ }
+ else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
- return UnlockAndMaybeComplete
- ( FCB, Status, Irp, Irp->IoStatus.Information );
+ return UnlockAndMaybeComplete(FCB, Status, Irp, Irp->IoStatus.Information);
}
- } else if( RecvReq->AfdFlags & AFD_IMMEDIATE ) {
+ }
+ else if (RecvReq->AfdFlags & AFD_IMMEDIATE)
+ {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
Status = STATUS_CANT_WAIT;
FCB->PollState &= ~AFD_EVENT_RECEIVE;
- UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
+
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, TRUE);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
- } else {
+ }
+ else
+ {
FCB->PollState &= ~AFD_EVENT_RECEIVE;
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_RECV );
}
#include "tdiconn.h"
#include "debug.h"
-static VOID PrintEvents( ULONG Events ) {
+static VOID PrintEvents(ULONG Events)
+{
#if DBG
char *events_list[] = { "AFD_EVENT_RECEIVE",
"AFD_EVENT_OOB_RECEIVE",
#endif
}
-static VOID CopyBackStatus( PAFD_HANDLE HandleArray,
- UINT HandleCount ) {
+static VOID CopyBackStatus(PAFD_HANDLE HandleArray, UINT HandleCount)
+{
UINT i;
- for( i = 0; i < HandleCount; i++ ) {
- HandleArray[i].Events = HandleArray[i].Status;
- HandleArray[i].Status = 0;
+ for (i = 0; i<HandleCount; i++)
+ {
+ HandleArray[i].Events = HandleArray[i].Status;
+ HandleArray[i].Status = 0;
}
}
-VOID ZeroEvents( PAFD_HANDLE HandleArray,
- UINT HandleCount ) {
+VOID ZeroEvents(PAFD_HANDLE HandleArray, UINT HandleCount)
+{
UINT i;
- for( i = 0; i < HandleCount; i++ ) {
- HandleArray[i].Status = 0;
- HandleArray[i].Events = 0;
+ for (i = 0; i<HandleCount; i++)
+ {
+ HandleArray[i].Status = 0;
+ HandleArray[i].Events = 0;
}
}
/* you must pass either Poll OR Irp */
-VOID SignalSocket(
- PAFD_ACTIVE_POLL Poll OPTIONAL,
- PIRP _Irp OPTIONAL,
- PAFD_POLL_INFO PollReq,
- NTSTATUS Status
- )
+VOID SignalSocket
+( PAFD_ACTIVE_POLL Poll OPTIONAL,
+ PIRP _Irp OPTIONAL,
+ PAFD_POLL_INFO PollReq,
+ NTSTATUS Status )
{
UINT i;
PIRP Irp = _Irp ? _Irp : Poll->Irp;
if (Poll)
{
- KeCancelTimer( &Poll->Timer );
- RemoveEntryList( &Poll->ListEntry );
- ExFreePool( Poll );
- }
+ KeCancelTimer( &Poll->Timer );
+ RemoveEntryList( &Poll->ListEntry );
+ ExFreePool( Poll );
+ }
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information =
FIELD_OFFSET(AFD_POLL_INFO, Handles) + sizeof(AFD_HANDLE) * PollReq->HandleCount;
- CopyBackStatus( PollReq->Handles,
- PollReq->HandleCount );
- for( i = 0; i < PollReq->HandleCount; i++ ) {
+
+ CopyBackStatus( PollReq->Handles, PollReq->HandleCount);
+ for (i=0; i < PollReq->HandleCount; i++)
+ {
AFD_DbgPrint
(MAX_TRACE,
("Handle(%x): Got %x,%x\n",
PollReq->Handles[i].Events,
PollReq->Handles[i].Status));
}
+
UnlockHandles( AFD_HANDLES(PollReq), PollReq->HandleCount );
- if( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
+ if (Irp->MdlAddress)
+ UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
+
AFD_DbgPrint(MID_TRACE,("Completing\n"));
+
(void)IoSetCancelRoutine(Irp, NULL);
IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+
AFD_DbgPrint(MID_TRACE,("Done\n"));
}
static VOID SelectTimeout( PKDPC Dpc,
PVOID DeferredContext,
PVOID SystemArgument1,
- PVOID SystemArgument2 ) {
- PAFD_ACTIVE_POLL Poll = DeferredContext;
+ PVOID SystemArgument2 )
+{
+ PAFD_ACTIVE_POLL Poll = (PAFD_ACTIVE_POLL)DeferredContext;
PAFD_POLL_INFO PollReq;
PIRP Irp;
KIRQL OldIrql;
VOID KillSelectsForFCB( PAFD_DEVICE_EXTENSION DeviceExt,
PFILE_OBJECT FileObject,
- BOOLEAN OnlyExclusive ) {
+ BOOLEAN OnlyExclusive )
+{
KIRQL OldIrql;
PLIST_ENTRY ListEntry;
PAFD_ACTIVE_POLL Poll;
KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
ListEntry = DeviceExt->Polls.Flink;
- while ( ListEntry != &DeviceExt->Polls ) {
- Poll = CONTAINING_RECORD(ListEntry, AFD_ACTIVE_POLL, ListEntry);
- ListEntry = ListEntry->Flink;
+ while (ListEntry != &DeviceExt->Polls)
+ {
+ Poll = CONTAINING_RECORD(ListEntry, AFD_ACTIVE_POLL, ListEntry);
+ ListEntry = ListEntry->Flink;
Irp = Poll->Irp;
PollReq = Irp->AssociatedIrp.SystemBuffer;
HandleArray = AFD_HANDLES(PollReq);
- for( i = 0; i < PollReq->HandleCount; i++ ) {
+ for (i = 0; i < PollReq->HandleCount; i++)
+ {
AFD_DbgPrint(MAX_TRACE,("Req: %x, This %x\n",
HandleArray[i].Handle, FileObject));
- if( (PVOID)HandleArray[i].Handle == FileObject &&
- (!OnlyExclusive || (OnlyExclusive && Poll->Exclusive)) ) {
+
+ if ((PVOID)HandleArray[i].Handle == FileObject &&
+ (!OnlyExclusive || (OnlyExclusive && Poll->Exclusive)) )
+ {
ZeroEvents( PollReq->Handles, PollReq->HandleCount );
SignalSocket( Poll, NULL, PollReq, STATUS_CANCELLED );
}
- }
+ }
}
KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
AFD_DbgPrint(MID_TRACE,("Done\n"));
}
-NTSTATUS NTAPI
-AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_NO_MEMORY;
PAFD_FCB FCB;
PFILE_OBJECT FileObject;
- PAFD_POLL_INFO PollReq = Irp->AssociatedIrp.SystemBuffer;
+ PAFD_POLL_INFO PollReq = (PAFD_POLL_INFO)Irp->AssociatedIrp.SystemBuffer;
PAFD_DEVICE_EXTENSION DeviceExt = DeviceObject->DeviceExtension;
UINT CopySize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
- UINT AllocSize =
- CopySize + sizeof(AFD_ACTIVE_POLL) - sizeof(AFD_POLL_INFO);
+ UINT AllocSize = CopySize + sizeof(AFD_ACTIVE_POLL) - sizeof(AFD_POLL_INFO);
KIRQL OldIrql;
UINT i, Signalled = 0;
ULONG Exclusive = PollReq->Exclusive;
SET_AFD_HANDLES(PollReq,
LockHandles( PollReq->Handles, PollReq->HandleCount ));
- if( !AFD_HANDLES(PollReq) ) {
- Irp->IoStatus.Status = STATUS_NO_MEMORY;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
- return STATUS_NO_MEMORY;
+ if (!AFD_HANDLES(PollReq))
+ {
+ Irp->IoStatus.Status = STATUS_NO_MEMORY;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+ return STATUS_NO_MEMORY;
}
- if( Exclusive ) {
- for( i = 0; i < PollReq->HandleCount; i++ ) {
- if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
+ if (Exclusive)
+ {
+ for (i = 0; i<PollReq->HandleCount; i++)
+ {
+ if (!AFD_HANDLES(PollReq)[i].Handle)
+ continue;
- KillSelectsForFCB( DeviceExt,
+ KillSelectsForFCB(DeviceExt,
(PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle,
TRUE );
}
KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
- for( i = 0; i < PollReq->HandleCount; i++ ) {
- if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
+ for (i=0; i<PollReq->HandleCount; i++)
+ {
+ if (!AFD_HANDLES(PollReq)[i].Handle)
+ continue;
FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
FCB = FileObject->FsContext;
PrintEvents( PollReq->Handles[i].Events );
AFD_DbgPrint(MID_TRACE,("\n"));
- PollReq->Handles[i].Status =
- PollReq->Handles[i].Events & FCB->PollState;
- if( PollReq->Handles[i].Status ) {
+ PollReq->Handles[i].Status = PollReq->Handles[i].Events & FCB->PollState;
+ if (PollReq->Handles[i].Status)
+ {
AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n",
FCB, FCB->PollState));
Signalled++;
}
}
- if( Signalled ) {
+ if (Signalled)
+ {
Status = STATUS_SUCCESS;
Irp->IoStatus.Status = Status;
SignalSocket( NULL, Irp, PollReq, Status );
- } else {
-
- PAFD_ACTIVE_POLL Poll = NULL;
+ }
+ else
+ {
+ PAFD_ACTIVE_POLL Poll = NULL;
- Poll = ExAllocatePool( NonPagedPool, AllocSize );
+ Poll = ExAllocatePool( NonPagedPool, AllocSize );
- if (Poll){
- Poll->Irp = Irp;
- Poll->DeviceExt = DeviceExt;
- Poll->Exclusive = Exclusive;
+ if (Poll)
+ {
+ Poll->Irp = Irp;
+ Poll->DeviceExt = DeviceExt;
+ Poll->Exclusive = Exclusive;
- KeInitializeTimerEx( &Poll->Timer, NotificationTimer );
+ KeInitializeTimerEx( &Poll->Timer, NotificationTimer );
- KeInitializeDpc( (PRKDPC)&Poll->TimeoutDpc,
- (PKDEFERRED_ROUTINE)SelectTimeout,
- Poll );
+ KeInitializeDpc( (PRKDPC)&Poll->TimeoutDpc,
+ (PKDEFERRED_ROUTINE)SelectTimeout,
+ Poll );
- InsertTailList( &DeviceExt->Polls, &Poll->ListEntry );
+ InsertTailList( &DeviceExt->Polls, &Poll->ListEntry );
- KeSetTimer( &Poll->Timer, PollReq->Timeout, &Poll->TimeoutDpc );
+ KeSetTimer( &Poll->Timer, PollReq->Timeout, &Poll->TimeoutDpc );
- Status = STATUS_PENDING;
- IoMarkIrpPending( Irp );
- (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
- } else {
- AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
- Status = STATUS_NO_MEMORY;
- }
+ Status = STATUS_PENDING;
+ IoMarkIrpPending( Irp );
+ (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
+ }
+ else
+ {
+ AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
+ Status = STATUS_NO_MEMORY;
+ }
}
KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
return Status;
}
-NTSTATUS NTAPI
-AfdEventSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdEventSelect(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
PFILE_OBJECT FileObject = IrpSp->FileObject;
NTSTATUS Status = STATUS_NO_MEMORY;
PAFD_EVENT_SELECT_INFO EventSelectInfo =
(PAFD_EVENT_SELECT_INFO)LockRequest( Irp, IrpSp );
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
- if( !SocketAcquireStateLock( FCB ) ) {
- return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ {
+ return LostSocket(Irp);
}
- if ( !EventSelectInfo ) {
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
- 0 );
+ if (!EventSelectInfo)
+ {
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
+
AFD_DbgPrint(MID_TRACE,("Called (Event %x Triggers %x)\n",
EventSelectInfo->EventObject,
EventSelectInfo->Events));
- if( FCB->EventSelect ) ObDereferenceObject( FCB->EventSelect );
+ if (FCB->EventSelect)
+ ObDereferenceObject(FCB->EventSelect);
FCB->EventSelect = NULL;
- if( EventSelectInfo->EventObject && EventSelectInfo->Events ) {
- Status = ObReferenceObjectByHandle( (PVOID)EventSelectInfo->
- EventObject,
- FILE_ALL_ACCESS,
- ExEventObjectType,
- UserMode,
- (PVOID *)&FCB->EventSelect,
- NULL );
-
- if( !NT_SUCCESS(Status) )
- FCB->EventSelect = NULL;
- else
- FCB->EventSelectTriggers = EventSelectInfo->Events;
- } else {
+ if (EventSelectInfo->EventObject && EventSelectInfo->Events)
+ {
+ Status = ObReferenceObjectByHandle(
+ (PVOID)EventSelectInfo->EventObject,
+ FILE_ALL_ACCESS,
+ ExEventObjectType,
+ UserMode,
+ (PVOID *)&FCB->EventSelect,
+ NULL );
+
+ if( !NT_SUCCESS(Status) )
+ FCB->EventSelect = NULL;
+ else
+ FCB->EventSelectTriggers = EventSelectInfo->Events;
+ }
+ else
+ {
FCB->EventSelect = NULL;
FCB->EventSelectTriggers = 0;
- Status = STATUS_SUCCESS;
+ Status = STATUS_SUCCESS;
}
AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
- return UnlockAndMaybeComplete( FCB, Status, Irp,
- 0 );
+ return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
}
-NTSTATUS NTAPI
-AfdEnumEvents( PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp ) {
+NTSTATUS
+NTAPI
+AfdEnumEvents(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
+{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_ENUM_NETWORK_EVENTS_INFO EnumReq =
(PAFD_ENUM_NETWORK_EVENTS_INFO)LockRequest( Irp, IrpSp );
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
AFD_DbgPrint(MID_TRACE,("Called (FCB %x)\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) {
- return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ {
+ return LostSocket( Irp );
}
- if ( !EnumReq ) {
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
- 0 );
+ if (!EnumReq)
+ {
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
EnumReq->PollEvents = FCB->PollState;
FCB->PollStatus,
sizeof(EnumReq->EventStatus) );
- return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp,
- 0 );
+ return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
/* * * NOTE ALWAYS CALLED AT DISPATCH_LEVEL * * */
-static BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject ) {
+static BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject )
+{
UINT i;
PAFD_FCB FCB;
UINT Signalled = 0;
- PAFD_POLL_INFO PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
+ PAFD_POLL_INFO PollReq = (PAFD_POLL_INFO)Poll->Irp->AssociatedIrp.SystemBuffer;
ASSERT( KeGetCurrentIrql() == DISPATCH_LEVEL );
- for( i = 0; i < PollReq->HandleCount; i++ ) {
- if( !AFD_HANDLES(PollReq)[i].Handle ) continue;
+ for (i = 0; i < PollReq->HandleCount; i++)
+ {
+ if ( !AFD_HANDLES(PollReq)[i].Handle )
+ continue;
- FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
- FCB = FileObject->FsContext;
+ FileObject = (PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle;
+ FCB = FileObject->FsContext;
- PollReq->Handles[i].Status = PollReq->Handles[i].Events & FCB->PollState;
- if( PollReq->Handles[i].Status ) {
- AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n",
- FCB, FCB->PollState));
- Signalled++;
- }
+ PollReq->Handles[i].Status = PollReq->Handles[i].Events & FCB->PollState;
+ if (PollReq->Handles[i].Status)
+ {
+ AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n", FCB, FCB->PollState));
+ Signalled++;
+ }
}
return Signalled ? 1 : 0;
}
-VOID PollReeval( PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject ) {
+VOID PollReeval(PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
+{
PAFD_ACTIVE_POLL Poll = NULL;
PLIST_ENTRY ThePollEnt = NULL;
PAFD_FCB FCB;
/* Take care of any event select signalling */
FCB = (PAFD_FCB)FileObject->FsContext;
- if( !FCB ) {
- KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
- return;
+ if (!FCB)
+ {
+ KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
+ return;
}
/* Now signal normal select irps */
ThePollEnt = DeviceExt->Polls.Flink;
- while( ThePollEnt != &DeviceExt->Polls ) {
- Poll = CONTAINING_RECORD( ThePollEnt, AFD_ACTIVE_POLL, ListEntry );
- PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
- AFD_DbgPrint(MID_TRACE,("Checking poll %x\n", Poll));
-
- if( UpdatePollWithFCB( Poll, FileObject ) ) {
- ThePollEnt = ThePollEnt->Flink;
- AFD_DbgPrint(MID_TRACE,("Signalling socket\n"));
- SignalSocket( Poll, NULL, PollReq, STATUS_SUCCESS );
- } else
- ThePollEnt = ThePollEnt->Flink;
+ while (ThePollEnt != &DeviceExt->Polls)
+ {
+ Poll = CONTAINING_RECORD( ThePollEnt, AFD_ACTIVE_POLL, ListEntry );
+ PollReq = Poll->Irp->AssociatedIrp.SystemBuffer;
+ AFD_DbgPrint(MID_TRACE,("Checking poll %x\n", Poll));
+
+ if (UpdatePollWithFCB(Poll, FileObject))
+ {
+ ThePollEnt = ThePollEnt->Flink;
+ AFD_DbgPrint(MID_TRACE,("Signalling socket\n"));
+ SignalSocket( Poll, NULL, PollReq, STATUS_SUCCESS );
+ }
+ else
+ ThePollEnt = ThePollEnt->Flink;
}
KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
- if( FCB->EventSelect && (FCB->PollState & FCB->EventSelectTriggers) ) {
+ if ( FCB->EventSelect && (FCB->PollState & FCB->EventSelectTriggers) )
+ {
AFD_DbgPrint(MID_TRACE,("Setting event %x\n", FCB->EventSelect));
KeSetEvent( FCB->EventSelect, IO_NETWORK_INCREMENT, FALSE );
}
#include "tdiconn.h"
#include "debug.h"
-static NTSTATUS NTAPI SendComplete
-( PDEVICE_OBJECT DeviceObject,
- PIRP Irp,
- PVOID Context ) {
+static
+NTSTATUS
+NTAPI
+SendComplete
+( PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PVOID Context )
+{
NTSTATUS Status = Irp->IoStatus.Status;
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
Irp->IoStatus.Status,
Irp->IoStatus.Information));
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
ASSERT(FCB->SendIrp.InFlightRequest == Irp);
FCB->SendIrp.InFlightRequest = NULL;
/* Request is not in flight any longer */
- if( FCB->State == SOCKET_STATE_CLOSED ) {
+ if (FCB->State == SOCKET_STATE_CLOSED)
+ {
/* Cleanup our IRP queue because the FCB is being destroyed */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
- NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
- NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
- SendReq = GetLockedData(NextIrp, NextIrpSp);
- NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
- NextIrp->IoStatus.Information = 0;
- UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
- IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
+ SendReq = GetLockedData(NextIrp, NextIrpSp);
+ NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
+ NextIrp->IoStatus.Information = 0;
+ UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
+
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
+ IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
- SocketStateUnlock( FCB );
- return STATUS_FILE_CLOSED;
+
+ SocketStateUnlock(FCB);
+ return STATUS_FILE_CLOSED;
}
- if( !NT_SUCCESS(Status) ) {
+ if (!NT_SUCCESS(Status))
+ {
/* Complete all following send IRPs with error */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
- NextIrpEntry =
- RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
- NextIrp =
- CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
SendReq = GetLockedData(NextIrp, NextIrpSp);
NextIrp->IoStatus.Status = Status;
NextIrp->IoStatus.Information = 0;
- if ( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
FCB->Send.BytesUsed - Irp->IoStatus.Information );
FCB->Send.BytesUsed -= Irp->IoStatus.Information;
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
- NextIrpEntry =
- RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
- NextIrp =
- CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
SendReq = GetLockedData(NextIrp, NextIrpSp);
Map = (PAFD_MAPBUF)(SendReq->BufferArray + SendReq->BufferCount);
SpaceAvail = FCB->Send.Size - FCB->Send.BytesUsed;
TotalBytesCopied = 0;
- for( i = 0; i < SendReq->BufferCount; i++ ) {
+ for (i = 0; i<SendReq->BufferCount; i++)
+ {
if (SpaceAvail < SendReq->BufferArray[i].len)
{
InsertHeadList(&FCB->PendingIrpList[FUNCTION_SEND],
NextIrp = NULL;
break;
}
- Map[i].BufferAddress =
- MmMapLockedPages( Map[i].Mdl, KernelMode );
+ Map[i].BufferAddress = MmMapLockedPages( Map[i].Mdl, KernelMode );
RtlCopyMemory( FCB->Send.Window + FCB->Send.BytesUsed,
Map[i].BufferAddress,
SendReq->BufferCount,
FALSE );
- if (NextIrp->MdlAddress) UnlockRequest(NextIrp, NextIrpSp);
+ if (NextIrp->MdlAddress)
+ UnlockRequest(NextIrp, NextIrpSp);
IoCompleteRequest(NextIrp, IO_NETWORK_INCREMENT);
}
}
/* Some data is still waiting */
- if( FCB->Send.BytesUsed ) {
+ if (FCB->Send.BytesUsed)
+ {
FCB->PollState &= ~AFD_EVENT_SEND;
Status = TdiSend( &FCB->SendIrp.InFlightRequest,
&FCB->SendIrp.Iosb,
SendComplete,
FCB );
- } else {
+ }
+ else
+ {
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
return STATUS_SUCCESS;
}
-static NTSTATUS NTAPI PacketSocketSendComplete
-( PDEVICE_OBJECT DeviceObject,
- PIRP Irp,
- PVOID Context ) {
+static
+NTSTATUS
+NTAPI
+PacketSocketSendComplete
+( PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PVOID Context)
+{
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
PIRP NextIrp;
Irp->IoStatus.Status,
Irp->IoStatus.Information));
- if( !SocketAcquireStateLock( FCB ) )
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
ASSERT(FCB->SendIrp.InFlightRequest == Irp);
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
- if( FCB->State == SOCKET_STATE_CLOSED ) {
+ if (FCB->State == SOCKET_STATE_CLOSED)
+ {
/* Cleanup our IRP queue because the FCB is being destroyed */
- while( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
- NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
- NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
- NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
- NextIrp->IoStatus.Information = 0;
- if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
- (void)IoSetCancelRoutine(NextIrp, NULL);
- IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
+ while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
+ {
+ NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
+ NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
+ NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
+ NextIrp->IoStatus.Information = 0;
+
+ if (NextIrp->MdlAddress)
+ UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
+
+ (void)IoSetCancelRoutine(NextIrp, NULL);
+ IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
- SocketStateUnlock( FCB );
- return STATUS_FILE_CLOSED;
+
+ SocketStateUnlock( FCB );
+ return STATUS_FILE_CLOSED;
}
SocketStateUnlock( FCB );
return STATUS_SUCCESS;
}
-NTSTATUS NTAPI
-AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp, BOOLEAN Short) {
+NTSTATUS
+NTAPI
+AfdConnectedSocketWriteData
+( PDEVICE_OBJECT DeviceObject, PIRP Irp,
+ PIO_STACK_LOCATION IrpSp, BOOLEAN Short )
+{
NTSTATUS Status = STATUS_SUCCESS;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_SEND_INFO SendReq;
ULONG Information;
UINT TotalBytesCopied = 0, i, SpaceAvail = 0;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket( Irp );
- if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
+ if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
{
PAFD_SEND_INFO_UDP SendReq;
PTDI_CONNECTION_INFORMATION TargetAddress;
/* Check that the socket is bound */
- if( FCB->State != SOCKET_STATE_BOUND || !FCB->RemoteAddress )
- return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp,
- 0 );
+ if (FCB->State != SOCKET_STATE_BOUND || !FCB->RemoteAddress)
+ return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
- if( !(SendReq = LockRequest( Irp, IrpSp )) )
+ if (!(SendReq = LockRequest(Irp, IrpSp)))
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
/* Must lock buffers before handing off user data */
NULL, NULL,
FALSE, FALSE );
- if( !SendReq->BufferArray ) {
- return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
- Irp, 0 );
+ if ( !SendReq->BufferArray )
+ {
+ return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
}
Status = TdiBuildConnectionInfo( &TargetAddress, FCB->RemoteAddress );
- if( NT_SUCCESS(Status) ) {
+ if (NT_SUCCESS(Status))
+ {
Status = TdiSendDatagram
( &FCB->SendIrp.InFlightRequest,
FCB->AddressFile.Object,
ExFreePool( TargetAddress );
}
- if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
+ if (Status == STATUS_PENDING)
+ Status = STATUS_SUCCESS;
AFD_DbgPrint(MID_TRACE,("Dismissing request: %x\n", Status));
return UnlockAndMaybeComplete( FCB, Status, Irp, Information );
}
- if( !(SendReq = LockRequest( Irp, IrpSp )) )
+ if( !(SendReq = LockRequest(Irp, IrpSp)))
return UnlockAndMaybeComplete
( FCB, STATUS_NO_MEMORY, Irp, TotalBytesCopied );
NULL, NULL,
FALSE, FALSE );
- if( !SendReq->BufferArray ) {
- return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
- Irp, 0 );
+ if (!SendReq->BufferArray)
+ {
+ return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
}
AFD_DbgPrint(MID_TRACE,("Socket state %d\n", FCB->State));
- if( FCB->State != SOCKET_STATE_CONNECTED ) {
- if( SendReq->AfdFlags & AFD_IMMEDIATE ) {
+ if (FCB->State != SOCKET_STATE_CONNECTED)
+ {
+ if (SendReq->AfdFlags & AFD_IMMEDIATE)
+ {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
- UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
- return UnlockAndMaybeComplete
- ( FCB, STATUS_CANT_WAIT, Irp, 0 );
- } else {
+ UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
+ return UnlockAndMaybeComplete(FCB, STATUS_CANT_WAIT, Irp, 0);
+ }
+ else
+ {
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
AFD_DbgPrint(MID_TRACE,("We can accept %d bytes\n",
SpaceAvail));
- for( i = 0; FCB->Send.BytesUsed < FCB->Send.Size &&
- i < SendReq->BufferCount; i++ ) {
+ for (i = 0;
+ FCB->Send.BytesUsed < FCB->Send.Size && i < SendReq->BufferCount;
+ i++ )
+ {
if (SpaceAvail < SendReq->BufferArray[i].len)
{
SpaceAvail -= SendReq->BufferArray[i].len;
}
- if( TotalBytesCopied == 0 ) {
+ if (TotalBytesCopied == 0)
+ {
AFD_DbgPrint(MID_TRACE,("Empty send\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
- return UnlockAndMaybeComplete
- ( FCB, STATUS_SUCCESS, Irp, TotalBytesCopied );
+ return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, TotalBytesCopied);
}
if (!NoSpace)
}
else
{
- if( SendReq->AfdFlags & AFD_IMMEDIATE ) {
+ if (SendReq->AfdFlags & AFD_IMMEDIATE)
+ {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete
( FCB, STATUS_CANT_WAIT, Irp, 0 );
- } else {
+ }
+ else
+ {
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
SendComplete,
FCB );
- if( Status == STATUS_PENDING )
+ if (Status == STATUS_PENDING)
Status = STATUS_SUCCESS;
AFD_DbgPrint(MID_TRACE,("Dismissing request: %x (%d)\n",
Status, TotalBytesCopied));
}
- return UnlockAndMaybeComplete
- ( FCB, Status, Irp, TotalBytesCopied );
+ return UnlockAndMaybeComplete(FCB, Status, Irp, TotalBytesCopied);
}
-NTSTATUS NTAPI
-AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp) {
+NTSTATUS
+NTAPI
+AfdPacketSocketWriteData
+( PDEVICE_OBJECT DeviceObject,
+ PIRP Irp,
+ PIO_STACK_LOCATION IrpSp)
+{
NTSTATUS Status = STATUS_SUCCESS;
PTDI_CONNECTION_INFORMATION TargetAddress;
PFILE_OBJECT FileObject = IrpSp->FileObject;
- PAFD_FCB FCB = FileObject->FsContext;
+ PAFD_FCB FCB = (PAFD_FCB)FileObject->FsContext;
PAFD_SEND_INFO_UDP SendReq;
ULONG Information;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ if (!SocketAcquireStateLock(FCB))
+ return LostSocket(Irp);
/* Check that the socket is bound */
- if( FCB->State != SOCKET_STATE_BOUND &&
+ if ( FCB->State != SOCKET_STATE_BOUND &&
FCB->State != SOCKET_STATE_CREATED)
- return UnlockAndMaybeComplete
- ( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
- if( !(SendReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete
- ( FCB, STATUS_NO_MEMORY, Irp, 0 );
+ return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
+
+ if( !(SendReq = LockRequest(Irp, IrpSp)))
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->State == SOCKET_STATE_CREATED)
{
- if( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
+ if (FCB->LocalAddress)
+ ExFreePool(FCB->LocalAddress);
FCB->LocalAddress =
- TaBuildNullTransportAddress( ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
- Address[0].AddressType );
+ TaBuildNullTransportAddress(
+ ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->Address[0].AddressType);
- if( FCB->LocalAddress ) {
+ if (FCB->LocalAddress)
+ {
Status = WarmSocketForBind( FCB );
- if( NT_SUCCESS(Status) )
+ if (NT_SUCCESS(Status))
FCB->State = SOCKET_STATE_BOUND;
else
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
- } else
- return UnlockAndMaybeComplete
- ( FCB, STATUS_NO_MEMORY, Irp, 0 );
+ }
+ else
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
}
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
NULL, NULL,
FALSE, FALSE );
- if( !SendReq->BufferArray )
- return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
- Irp, 0 );
+ if (!SendReq->BufferArray)
+ return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
AFD_DbgPrint
(MID_TRACE,("RemoteAddress #%d Type %d\n",
/* Check the size of the Address given ... */
- if( NT_SUCCESS(Status) ) {
+ if (NT_SUCCESS(Status))
+ {
FCB->PollState &= ~AFD_EVENT_SEND;
Status = TdiSendDatagram
PacketSocketSendComplete,
FCB );
- ExFreePool( TargetAddress );
+ ExFreePool(TargetAddress);
}
- if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
+ if (Status == STATUS_PENDING)
+ Status = STATUS_SUCCESS;
AFD_DbgPrint(MID_TRACE,("Dismissing request: %x\n", Status));
* point. */
Information = SendReq->BufferArray[0].len;
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
+
return UnlockAndMaybeComplete( FCB, Status, Irp, Information );
}
* Status of operation
*/
{
- PCONNECTION_ENDPOINT Connection;
- PTDI_REQUEST_KERNEL Parameters;
- PTRANSPORT_CONTEXT TranContext;
- PIO_STACK_LOCATION IrpSp;
- NTSTATUS Status;
+ PCONNECTION_ENDPOINT Connection;
+ PTDI_REQUEST_KERNEL Parameters;
+ PTRANSPORT_CONTEXT TranContext;
+ PIO_STACK_LOCATION IrpSp;
+ NTSTATUS Status;
- TI_DbgPrint(DEBUG_IRP, ("[TCPIP, DispTdiConnect] Called\n"));
+ TI_DbgPrint(DEBUG_IRP, ("[TCPIP, DispTdiConnect] Called\n"));
- IrpSp = IoGetCurrentIrpStackLocation(Irp);
+ IrpSp = IoGetCurrentIrpStackLocation(Irp);
- /* Get associated connection endpoint file object. Quit if none exists */
+ /* Get associated connection endpoint file object. Quit if none exists */
- TranContext = IrpSp->FileObject->FsContext;
- if (!TranContext) {
- TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
- Status = STATUS_INVALID_PARAMETER;
- goto done;
- }
+ TranContext = IrpSp->FileObject->FsContext;
+ if (!TranContext)
+ {
+ TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
+ Status = STATUS_INVALID_PARAMETER;
+ goto done;
+ }
- Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
- if (!Connection) {
- TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
- Status = STATUS_INVALID_PARAMETER;
- goto done;
- }
+ Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
+ if (!Connection)
+ {
+ TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
+ Status = STATUS_INVALID_PARAMETER;
+ goto done;
+ }
- Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
+ Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
- Status = DispPrepareIrpForCancel(TranContext->Handle.ConnectionContext,
- Irp,
- DispCancelRequest);
+ Status = DispPrepareIrpForCancel(TranContext->Handle.ConnectionContext,
+ Irp,
+ DispCancelRequest);
- if (NT_SUCCESS(Status))
- {
- Status = TCPConnect(
- TranContext->Handle.ConnectionContext,
- Parameters->RequestConnectionInformation,
- Parameters->ReturnConnectionInformation,
- DispDataRequestComplete,
- Irp );
- }
+ if (NT_SUCCESS(Status))
+ {
+ Status = TCPConnect(
+ TranContext->Handle.ConnectionContext,
+ Parameters->RequestConnectionInformation,
+ Parameters->ReturnConnectionInformation,
+ DispDataRequestComplete,
+ Irp );
+ }
-done:
- if (Status != STATUS_PENDING) {
- DispDataRequestComplete(Irp, Status, 0);
- } else
- IoMarkIrpPending(Irp);
+ done:
+ if (Status != STATUS_PENDING)
+ {
+ DispDataRequestComplete(Irp, Status, 0);
+ }
+ else
+ IoMarkIrpPending(Irp);
- TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiConnect] TCP Connect returned %08x\n", Status));
+ TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiConnect] TCP Connect returned %08x\n", Status));
- return Status;
+ return Status;
}
NTSTATUS DispTdiDisconnect(
* Status of operation
*/
{
- NTSTATUS Status;
- PTDI_REQUEST_KERNEL_DISCONNECT DisReq;
- PCONNECTION_ENDPOINT Connection;
- PTRANSPORT_CONTEXT TranContext;
- PIO_STACK_LOCATION IrpSp;
+ NTSTATUS Status;
+ PTDI_REQUEST_KERNEL_DISCONNECT DisReq;
+ PCONNECTION_ENDPOINT Connection;
+ PTRANSPORT_CONTEXT TranContext;
+ PIO_STACK_LOCATION IrpSp;
- TI_DbgPrint(DEBUG_IRP, ("[TCPIP, DispTdiDisconnect] Called\n"));
+ TI_DbgPrint(DEBUG_IRP, ("[TCPIP, DispTdiDisconnect] Called\n"));
- IrpSp = IoGetCurrentIrpStackLocation(Irp);
- DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters;
+ IrpSp = IoGetCurrentIrpStackLocation(Irp);
+ DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters;
- /* Get associated connection endpoint file object. Quit if none exists */
+ /* Get associated connection endpoint file object. Quit if none exists */
- TranContext = IrpSp->FileObject->FsContext;
- if (!TranContext) {
- TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
- Status = STATUS_INVALID_PARAMETER;
- goto done;
- }
+ TranContext = IrpSp->FileObject->FsContext;
+ if (!TranContext)
+ {
+ TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
+ Status = STATUS_INVALID_PARAMETER;
+ goto done;
+ }
- Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
- if (!Connection)
- {
- TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
- Status = STATUS_INVALID_PARAMETER;
- goto done;
- }
+ Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
+ if (!Connection)
+ {
+ TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
+ Status = STATUS_INVALID_PARAMETER;
+ goto done;
+ }
- Status = TCPDisconnect(
- TranContext->Handle.ConnectionContext,
- DisReq->RequestFlags,
- DisReq->RequestConnectionInformation,
- DisReq->ReturnConnectionInformation,
- DispDataRequestComplete,
- Irp );
+ Status = TCPDisconnect(
+ TranContext->Handle.ConnectionContext,
+ DisReq->RequestFlags,
+ DisReq->RequestConnectionInformation,
+ DisReq->ReturnConnectionInformation,
+ DispDataRequestComplete,
+ Irp );
-done:
- if (Status != STATUS_PENDING) {
- DispDataRequestComplete(Irp, Status, 0);
- } else
- IoMarkIrpPending(Irp);
+ done:
+ if (Status != STATUS_PENDING)
+ {
+ DispDataRequestComplete(Irp, Status, 0);
+ }
+ else
+ IoMarkIrpPending(Irp);
- TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiDisconnect] TCP Disconnect returned %08x\n", Status));
+ TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiDisconnect] TCP Disconnect returned %08x\n", Status));
- return Status;
+ return Status;
}
if (Status == STATUS_SUCCESS)
{
- DbgPrint("[IP, TCPAcceptEventHandler] newpcb->state = %s, listen_pcb->state = %s, newpcb->id = %d\n",
+ DbgPrint("[IP, TCPAcceptEventHandler] newpcb->state = %s, listen_pcb->state = %s, newpcb = 0x%x\n",
tcp_state_str[newpcb->state],
tcp_state_str[((struct tcp_pcb*)Connection->SocketContext)->state],
- newpcb->identifier);
+ newpcb);
LockObject(Bucket->AssociatedEndpoint, &OldIrql);
DbgPrint("[IP, TCPAcceptEventHandler] Trying to unlock Bucket->AssociatedEndpoint\n");
UnlockObject(Bucket->AssociatedEndpoint, OldIrql);
+ /* sanity assert...this should never be in a LISTEN state */
+ ASSERT(((struct tcp_pcb*)OldSocketContext)->state == CLOSED);
/* free socket context created in FileOpenConnection, as we're using a new
one; we free it asynchornously because otherwise we create a dedlock */
ChewCreate(SocketContextCloseWorker, OldSocketContext);
projects / reactos.git / commitdiff