Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 06:33:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

[AFD, FORMATTING]

Browse source 
- get rid of unused OskitDumpBuffer
- make the code in AFD better conform to ROS coding guidelines
- fix some MSVC compilation errors (still not fully compiling with MSVC yet)
[IP]
- Add a sanity check in the TCPAcceptEventHandler

svn path=/branches/GSoC_2011/TcpIpDriver/; revision=52398
This commit is contained in:
Claudiu Mihail 2011-06-21 11:46:47 +00:00
parent 8e61bd7196
commit 7ba87c3d72
12 changed files with 1375 additions and 1036 deletions
Download patch file Download diff file Expand all files Collapse all files

11
drivers/network/afd/afd/bind.c
View file

@ -55,13 +55,14 @@ NTSTATUS WarmSocketForBind( PAFD_FCB FCB )
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"));
@ -70,10 +71,11 @@ AfdBindSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 );
if (FCB->LocalAddress )
ExFreePool(FCB->LocalAddress);
FCB->LocalAddress = TaCopyTransportAddress(&BindReq->Address);
if (FCB->LocalAddress)
@ -116,4 +118,3 @@ AfdBindSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
/* MSAFD relies on us returning the address file handle in the IOSB */
return UnlockAndMaybeComplete( FCB, Status, Irp, (ULONG_PTR)FCB->AddressFile.Handle );
}

125
drivers/network/afd/afd/connect.c
View file

@ -12,15 +12,17 @@
#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);
@ -42,11 +44,12 @@ AfdSetConnectOptions(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 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);
@ -60,7 +63,8 @@ AfdSetConnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
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,
@ -77,11 +81,12 @@ AfdSetConnectOptionsSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -97,29 +102,33 @@ AfdSetConnectOptionsSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
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,
@ -134,11 +143,12 @@ AfdSetConnectData(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 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);
@ -152,11 +162,10 @@ AfdSetConnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
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;
@ -169,11 +178,12 @@ AfdSetConnectDataSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -189,7 +199,8 @@ AfdSetConnectDataSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
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;
@ -235,15 +246,15 @@ NTSTATUS MakeSocketIntoConnection( PAFD_FCB FCB )
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 ) {
if (!FCB->Send.Window)
{
ExFreePool( FCB->Recv.Window );
FCB->Recv.Window = NULL;
return STATUS_NO_MEMORY;
@ -260,7 +271,8 @@ NTSTATUS MakeSocketIntoConnection( PAFD_FCB FCB )
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;
@ -270,10 +282,14 @@ NTSTATUS MakeSocketIntoConnection( PAFD_FCB FCB )
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;
@ -311,6 +327,7 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
SocketStateUnlock( FCB );
return STATUS_FILE_CLOSED;
}
@ -336,23 +353,27 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
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( NT_SUCCESS(Status) ) {
if (NT_SUCCESS(Status))
{
Status = MakeSocketIntoConnection(FCB);
if( !NT_SUCCESS(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,
@ -360,7 +381,8 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
FCB->FilledConnectData);
}
FCB->FilledConnectOptions = MIN(FCB->ConnectInfo->OptionsLength, FCB->ConnectOptionsSize);
FCB->FilledConnectOptions = MIN(FCB->ConnectInfo->OptionsLength,
FCB->ConnectOptionsSize);
if (FCB->FilledConnectOptions)
{
RtlCopyMemory(FCB->ConnectOptions,
@ -368,13 +390,14 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
FCB->FilledConnectOptions);
}
if( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND] ) ) {
if (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP,
Tail.Overlay.ListEntry);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
AFD_DbgPrint(MID_TRACE,("Launching send request %x\n", NextIrp));
Status = AfdConnectedSocketWriteData
( DeviceObject,
Status = AfdConnectedSocketWriteData(DeviceObject,
NextIrp,
IoGetCurrentIrpStackLocation( NextIrp ),
FALSE);
@ -393,21 +416,23 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
/* 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 (!SocketAcquireStateLock(FCB))
return LostSocket( Irp );
if (!(ConnectReq = LockRequest(Irp, IrpSp)))
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
0 );
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Connect request:\n"));
DbgPrint("[AFD, AfdStreamSocketConnect] Connect request:\n");
@ -419,7 +444,9 @@ AfdStreamSocketConnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
if (FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS)
{
if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
if (FCB->RemoteAddress)
ExFreePool(FCB->RemoteAddress);
FCB->RemoteAddress = TaCopyTransportAddress( &ConnectReq->RemoteAddress );
if (!FCB->RemoteAddress)

48
drivers/network/afd/afd/context.c
View file

@ -12,22 +12,24 @@
#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 );
if (FCB->Context)
{
RtlCopyMemory( Irp->UserBuffer, FCB->Context, ContextSize );
Status = STATUS_SUCCESS;
}
@ -36,14 +38,16 @@ AfdGetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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));
@ -55,19 +59,22 @@ AfdGetContextSize( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 ) {
if (FCB->Context)
{
ExFreePool( FCB->Context );
FCB->ContextSize = 0;
}
@ -75,7 +82,8 @@ AfdSetContext( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;

129
drivers/network/afd/afd/info.c
View file

@ -13,25 +13,29 @@
#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 ) {
_SEH2_TRY
{
switch( InfoReq->InformationClass )
{
case AFD_INFO_RECEIVE_WINDOW_SIZE:
InfoReq->Information.Ulong = FCB->Recv.Size;
break;
@ -69,7 +73,6 @@ AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
InfoReq->Information.Ulong++;
CurrentEntry = CurrentEntry->Flink;
}
break;
default:
@ -78,31 +81,38 @@ AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
Status = STATUS_INVALID_PARAMETER;
break;
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
}
_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) {
_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;
@ -111,26 +121,32 @@ AfdSetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
AFD_DbgPrint(MIN_TRACE,("Unknown request %d\n", InfoReq->InformationClass));
break;
}
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = STATUS_INVALID_PARAMETER;
} _SEH2_END;
}
_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 ) {
if (FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL)
{
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
}
@ -141,44 +157,52 @@ AfdGetSockName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
FALSE,
NULL );
if( Mdl != NULL ) {
_SEH2_TRY {
if( Mdl != NULL )
{
_SEH2_TRY
{
MmProbeAndLockPages( Mdl, Irp->RequestorMode, IoModifyAccess );
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
Status = _SEH2_GetExceptionCode();
} _SEH2_END;
}
_SEH2_END;
if( NT_SUCCESS(Status) ) {
Status = TdiQueryInformation
( FCB->Connection.Object ? FCB->Connection.Object : FCB->AddressFile.Object,
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,
@ -190,12 +214,16 @@ AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
if (Mdl)
{
_SEH2_TRY {
_SEH2_TRY
{
MmProbeAndLockPages(Mdl, Irp->RequestorMode, IoModifyAccess);
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
Status = _SEH2_GetExceptionCode();
} _SEH2_END;
}
_SEH2_END;
if (NT_SUCCESS(Status))
{
@ -205,8 +233,11 @@ AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;
}

41
drivers/network/afd/afd/listen.c
View file

@ -12,11 +12,15 @@
#include "tdiconn.h"
#include "debug.h"
static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
static
NTSTATUS
SatisfyAccept
( PAFD_DEVICE_EXTENSION DeviceExt,
PIRP Irp,
PFILE_OBJECT NewFileObject,
PAFD_TDI_OBJECT_QELT Qelt ) {
PAFD_FCB FCB = NewFileObject->FsContext;
PAFD_TDI_OBJECT_QELT Qelt )
{
PAFD_FCB FCB = (PAFD_FCB)NewFileObject->FsContext;
NTSTATUS Status;
if( !SocketAcquireStateLock( FCB ) )
@ -28,9 +32,10 @@ static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
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;
@ -43,7 +48,9 @@ static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
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;
@ -110,7 +117,10 @@ static NTSTATUS SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt )
return STATUS_SUCCESS;
}
static NTSTATUS NTAPI ListenComplete
static
NTSTATUS
NTAPI
ListenComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context )
@ -265,7 +275,7 @@ NTSTATUS AfdListenSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
{
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));
@ -274,7 +284,7 @@ NTSTATUS AfdListenSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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)
@ -336,7 +346,7 @@ NTSTATUS AfdWaitForListen( 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;
NTSTATUS Status;
AFD_DbgPrint(MID_TRACE,("Called\n"));
@ -349,10 +359,8 @@ NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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");
@ -386,7 +394,8 @@ NTSTATUS AfdAccept( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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"));

183
drivers/network/afd/afd/lock.c
View file

@ -21,7 +21,8 @@ PVOID GetLockedData(PIRP Irp, PIO_STACK_LOCATION IrpSp)
}
/* 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);
@ -40,19 +41,27 @@ PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
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 ) {
if (LockFailed)
{
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
return NULL;
}
} else return NULL;
}
else
return NULL;
break;
case IRP_MJ_READ:
@ -66,19 +75,27 @@ PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
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 ) {
if (LockFailed)
{
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
return NULL;
}
} else return NULL;
}
else
return NULL;
break;
default:
@ -101,28 +118,36 @@ VOID UnlockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp )
* treat the address buffer as an ordinary client buffer. It's only used
* for datagrams. */
PAFD_WSABUF LockBuffers( PAFD_WSABUF Buf, UINT Count,
PAFD_WSABUF
LockBuffers
( PAFD_WSABUF Buf, UINT Count,
PVOID AddressBuf, PINT AddressLen,
BOOLEAN Write, BOOLEAN LockAddress ) {
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);
_SEH2_TRY {
_SEH2_TRY
{
RtlCopyMemory(NewBuf, Buf, sizeof(AFD_WSABUF) * Count);
if( LockAddress ) {
if (AddressBuf && AddressLen) {
if (LockAddress)
{
if (AddressBuf && AddressLen)
{
NewBuf[Count].buf = AddressBuf;
NewBuf[Count].len = *AddressLen;
NewBuf[Count + 1].buf = (PVOID)AddressLen;
@ -130,48 +155,64 @@ PAFD_WSABUF LockBuffers( PAFD_WSABUF Buf, UINT Count,
}
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);
_SEH2_YIELD(return NULL);
} _SEH2_END;
}
_SEH2_END;
for( i = 0; i < Count; i++ ) {
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 ) {
if (NewBuf[i].buf && NewBuf[i].len)
{
MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
NewBuf[i].len,
FALSE,
FALSE,
NULL );
} else {
}
else
{
MapBuf[i].Mdl = NULL;
continue;
}
AFD_DbgPrint(MID_TRACE,("NewMdl @ %x\n", MapBuf[i].Mdl));
if( MapBuf[i].Mdl ) {
if (MapBuf[i].Mdl)
{
AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
_SEH2_TRY {
_SEH2_TRY
{
MmProbeAndLockPages( MapBuf[i].Mdl, KernelMode,
Write ? IoModifyAccess : IoReadAccess );
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
LockFailed = TRUE;
} _SEH2_END;
}
_SEH2_END;
AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
if( LockFailed ) {
if (LockFailed)
{
IoFreeMdl( MapBuf[i].Mdl );
MapBuf[i].Mdl = NULL;
ExFreePool( NewBuf );
return NULL;
}
} else {
}
else
{
ExFreePool( NewBuf );
return NULL;
}
@ -183,15 +224,19 @@ PAFD_WSABUF LockBuffers( PAFD_WSABUF Buf, UINT Count,
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 ) {
for (i=0; i < Count + Lock; i++)
{
if (Map[i].Mdl)
{
MmUnlockPages( Map[i].Mdl );
IoFreeMdl( Map[i].Mdl );
Map[i].Mdl = NULL;
@ -204,19 +249,25 @@ VOID UnlockBuffers( PAFD_WSABUF Buf, UINT Count, BOOL Address ) {
/* 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++ ) {
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) ) {
if (!HandleArray[i].Handle)
continue;
if (NT_SUCCESS(Status))
{
Status = ObReferenceObjectByHandle
( (PVOID)HandleArray[i].Handle,
FILE_ALL_ACCESS,
@ -230,7 +281,8 @@ PAFD_HANDLE LockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
FileObjects[i].Handle = 0;
}
if( !NT_SUCCESS(Status) ) {
if (!NT_SUCCESS(Status))
{
UnlockHandles(FileObjects, HandleCount);
return NULL;
}
@ -238,10 +290,12 @@ PAFD_HANDLE LockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
return FileObjects;
}
VOID UnlockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
VOID UnlockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
{
UINT i;
for( i = 0; i < HandleCount; i++ ) {
for (i = 0; i < HandleCount; i++)
{
if (HandleArray[i].Handle)
ObDereferenceObject( (PVOID)HandleArray[i].Handle );
}
@ -250,8 +304,10 @@ VOID UnlockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
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,
@ -260,34 +316,50 @@ BOOLEAN SocketAcquireStateLock( PAFD_FCB FCB ) {
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);
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 ) );
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) */
@ -314,8 +386,7 @@ NTSTATUS LeaveIrpUntilLater( PAFD_FCB FCB, PIRP Irp, UINT Function ) {
* 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;
}

131
drivers/network/afd/afd/main.c
View file

@ -25,27 +25,14 @@ DWORD DebugTraceLevel = 0;
#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)
{
@ -53,7 +40,8 @@ AfdGetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -79,7 +67,8 @@ AfdSetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -116,7 +105,8 @@ AfdSetDisconnectOptionsSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -141,7 +131,8 @@ AfdSetDisconnectOptionsSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
NTSTATUS NTAPI
NTSTATUS
NTAPI
AfdGetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
@ -149,14 +140,16 @@ AfdGetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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,
@ -171,11 +164,12 @@ AfdSetDisconnectData(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 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);
@ -208,11 +202,12 @@ AfdSetDisconnectDataSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -237,13 +232,15 @@ AfdSetDisconnectDataSize(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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);
@ -264,7 +261,9 @@ AfdGetTdiHandles(PDEVICE_OBJECT DeviceObject, PIRP Irp,
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
static NTSTATUS NTAPI
static
NTSTATUS
NTAPI
AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
@ -306,7 +305,7 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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)
@ -316,7 +315,8 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 ) );
@ -345,8 +345,8 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
{
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)
@ -354,6 +354,7 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
ExFreePool(FCB);
AFD_DbgPrint(MID_TRACE,("Could not copy target string\n"));
Irp->IoStatus.Status = STATUS_NO_MEMORY;
IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
return STATUS_NO_MEMORY;
}
@ -399,9 +400,10 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;
@ -437,7 +439,9 @@ AfdCleanupSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
return UnlockAndMaybeComplete(FCB, STATUS_SUCCESS, Irp, 0);
}
static NTSTATUS NTAPI
static
NTSTATUS
NTAPI
AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
PIO_STACK_LOCATION IrpSp)
{
@ -449,8 +453,7 @@ AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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))
@ -590,23 +593,24 @@ AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 );
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if ( DisReq->DisconnectType & AFD_DISCONNECT_SEND)
Flags |= TDI_DISCONNECT_RELEASE;
@ -617,8 +621,7 @@ AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
if (!(FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS))
{
if (!FCB->ConnectInfo)
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
Irp, 0 );
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
ASSERT(FCB->RemoteAddress);
@ -626,8 +629,7 @@ AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
( &ConnectionReturnInfo, FCB->RemoteAddress->Address[0].AddressType );
if (!NT_SUCCESS(Status))
return UnlockAndMaybeComplete( FCB, Status,
Irp, 0 );
return UnlockAndMaybeComplete(FCB, Status, Irp, 0);
FCB->ConnectInfo->UserData = FCB->DisconnectData;
FCB->ConnectInfo->UserDataLength = FCB->DisconnectDataSize;
@ -687,7 +689,9 @@ AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
static NTSTATUS NTAPI
static
NTSTATUS
NTAPI
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
@ -883,7 +887,7 @@ CleanupPendingIrp(PAFD_FCB FCB, PIRP Irp, PIO_STACK_LOCATION IrpSp, PAFD_ACTIVE_
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 ||
@ -895,19 +899,20 @@ CleanupPendingIrp(PAFD_FCB FCB, PIRP Irp, PIO_STACK_LOCATION IrpSp, PAFD_ACTIVE_
}
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;
@ -1017,12 +1022,15 @@ AfdCancelHandler(PDEVICE_OBJECT DeviceObject,
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;
@ -1039,8 +1047,7 @@ DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
DriverObject->DriverUnload = AfdUnload;
Status = IoCreateDevice
( DriverObject,
Status = IoCreateDevice(DriverObject,
sizeof(AFD_DEVICE_EXTENSION),
&wstrDeviceName,
FILE_DEVICE_NAMED_PIPE,

344
drivers/network/afd/afd/read.c
View file

@ -28,8 +28,7 @@
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;
@ -39,18 +38,21 @@ static VOID HandleEOFOnIrp( PAFD_FCB FCB, NTSTATUS Status, ULONG_PTR Information
}
}
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)) ) {
!(FCB->PollState & (AFD_EVENT_CLOSE | AFD_EVENT_ABORT)))
{
AFD_DbgPrint(MID_TRACE,("Replenishing buffer\n"));
Status = TdiReceive( &FCB->ReceiveIrp.InFlightRequest,
@ -68,9 +70,13 @@ static VOID RefillSocketBuffer( PAFD_FCB FCB ) {
}
}
static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
static
NTSTATUS
TryToSatisfyRecvRequestFromBuffer
( PAFD_FCB FCB,
PAFD_RECV_INFO RecvReq,
PUINT TotalBytesCopied ) {
PUINT TotalBytesCopied )
{
UINT i, BytesToCopy = 0, FcbBytesCopied = FCB->Recv.BytesUsed,
BytesAvailable =
FCB->Recv.Content - FCB->Recv.BytesUsed;
@ -81,8 +87,10 @@ static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
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);
@ -90,14 +98,13 @@ static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
RecvReq->BufferCount,
RecvReq->BufferArray));
for (i = 0;
RecvReq->BufferArray &&
BytesAvailable &&
i < RecvReq->BufferCount;
i++ ) {
BytesToCopy =
MIN( RecvReq->BufferArray[i].len, BytesAvailable );
RecvReq->BufferArray && BytesAvailable && i < RecvReq->BufferCount;
i++)
{
BytesToCopy = MIN(RecvReq->BufferArray[i].len, BytesAvailable);
if( Map[i].Mdl ) {
if (Map[i].Mdl)
{
Map[i].BufferAddress = MmMapLockedPages( Map[i].Mdl, KernelMode );
AFD_DbgPrint(MID_TRACE,("Buffer %d: %x:%d\n",
@ -121,7 +128,8 @@ static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
}
/* 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;
@ -131,7 +139,10 @@ static NTSTATUS TryToSatisfyRecvRequestFromBuffer( PAFD_FCB FCB,
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;
@ -147,32 +158,38 @@ static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
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);
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;
NextIrp->IoStatus.Information = 0;
if( NextIrp == Irp ) RetStatus = Status;
if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
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 */
@ -181,36 +198,41 @@ static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
/*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);
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 ) );
if (NextIrp->MdlAddress)
UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
@ -218,17 +240,20 @@ static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
}
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;
}
@ -236,10 +261,13 @@ static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
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;
@ -257,10 +285,13 @@ NTSTATUS NTAPI ReceiveComplete
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] ) ) {
while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrpSp = IoGetCurrentIrpStackLocation(NextIrp);
@ -268,13 +299,19 @@ NTSTATUS NTAPI ReceiveComplete
NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
NextIrp->IoStatus.Information = 0;
UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
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 ) {
}
else if (FCB->State == SOCKET_STATE_LISTENING)
{
AFD_DbgPrint(MIN_TRACE,("!!! LISTENER GOT A RECEIVE COMPLETE !!!\n"));
SocketStateUnlock( FCB );
return STATUS_INVALID_PARAMETER;
@ -289,21 +326,27 @@ NTSTATUS NTAPI ReceiveComplete
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,
@ -313,13 +356,11 @@ AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 );
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
@ -328,9 +369,9 @@ AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;
@ -343,19 +384,23 @@ AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 ) {
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));
}
@ -364,14 +409,17 @@ AfdConnectedSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
static NTSTATUS NTAPI
SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
static
NTSTATUS
NTAPI
SatisfyPacketRecvRequest
( PAFD_FCB FCB, PIRP Irp,
PAFD_STORED_DATAGRAM DatagramRecv,
PUINT TotalBytesCopied ) {
PUINT TotalBytesCopied )
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
PAFD_RECV_INFO RecvReq =
GetLockedData(Irp, IrpSp);
PAFD_RECV_INFO RecvReq = (PAFD_RECV_INFO)GetLockedData(Irp, IrpSp);
UINT BytesToCopy = 0, BytesAvailable = DatagramRecv->Len, AddrLen = 0;
PAFD_MAPBUF Map;
@ -379,18 +427,20 @@ SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
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",
@ -454,13 +504,15 @@ SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
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;
@ -477,9 +529,11 @@ PacketSocketRecvComplete(
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] ) ) {
while ( !IsListEmpty( &FCB->PendingIrpList[FUNCTION_RECV]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_RECV]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
@ -487,13 +541,17 @@ PacketSocketRecvComplete(
NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
NextIrp->IoStatus.Information = 0;
UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, FALSE);
if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
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 ) ) {
while (!IsListEmpty(&FCB->DatagramList))
{
DatagramRecvEntry = RemoveHeadList(&FCB->DatagramList);
DatagramRecv = CONTAINING_RECORD(DatagramRecvEntry, AFD_STORED_DATAGRAM, ListEntry);
ExFreePool( DatagramRecv->Address );
@ -512,7 +570,8 @@ PacketSocketRecvComplete(
DatagramRecv = ExAllocatePool( NonPagedPool, DGSize );
if( DatagramRecv ) {
if (DatagramRecv)
{
DatagramRecv->Len = Irp->IoStatus.Information;
RtlCopyMemory( DatagramRecv->Buffer, FCB->Recv.Window,
DatagramRecv->Len );
@ -521,22 +580,29 @@ PacketSocketRecvComplete(
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 );
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,
@ -550,7 +616,8 @@ PacketSocketRecvComplete(
RecvReq, DatagramRecv));
if (DatagramRecv->Len > RecvReq->BufferArray[0].len &&
!(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL) ) {
!(RecvReq->TdiFlags & TDI_RECEIVE_PARTIAL))
{
InsertHeadList( &FCB->DatagramList,
&DatagramRecv->ListEntry );
Status = NextIrp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
@ -559,7 +626,9 @@ PacketSocketRecvComplete(
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,
@ -569,24 +638,30 @@ PacketSocketRecvComplete(
InsertHeadList(&FCB->DatagramList,
&DatagramRecv->ListEntry);
}
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,
@ -605,27 +680,31 @@ PacketSocketRecvComplete(
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)
return UnlockAndMaybeComplete
( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
if ( !(RecvReq = LockRequest(Irp, IrpSp)))
return UnlockAndMaybeComplete
( FCB, STATUS_NO_MEMORY, Irp, 0 );
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
AFD_DbgPrint(MID_TRACE,("Recv flags %x\n", RecvReq->AfdFlags));
@ -635,36 +714,41 @@ AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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,
return UnlockAndMaybeComplete(FCB, Status, Irp, Irp->IoStatus.Information);
}
else
{
Status = SatisfyPacketRecvRequest(
FCB, Irp, DatagramRecv,
(PUINT)&Irp->IoStatus.Information);
if (RecvReq->TdiFlags & TDI_RECEIVE_PEEK)
@ -673,25 +757,31 @@ AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
&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);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
} else {
}
else
{
FCB->PollState &= ~AFD_EVENT_RECEIVE;
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_RECV );
}

199
drivers/network/afd/afd/select.c
View file

@ -12,7 +12,8 @@
#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",
@ -33,21 +34,23 @@ static VOID PrintEvents( ULONG Events ) {
#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++ ) {
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++ ) {
for (i = 0; i<HandleCount; i++)
{
HandleArray[i].Status = 0;
HandleArray[i].Events = 0;
}
@ -55,12 +58,11 @@ VOID ZeroEvents( PAFD_HANDLE HandleArray,
/* you must pass either Poll OR Irp */
VOID SignalSocket(
PAFD_ACTIVE_POLL Poll OPTIONAL,
VOID SignalSocket
( PAFD_ACTIVE_POLL Poll OPTIONAL,
PIRP _Irp OPTIONAL,
PAFD_POLL_INFO PollReq,
NTSTATUS Status
)
NTSTATUS Status )
{
UINT i;
PIRP Irp = _Irp ? _Irp : Poll->Irp;
@ -76,9 +78,10 @@ VOID SignalSocket(
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",
@ -86,19 +89,25 @@ VOID SignalSocket(
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;
@ -121,7 +130,8 @@ static VOID SelectTimeout( PKDPC Dpc,
VOID KillSelectsForFCB( PAFD_DEVICE_EXTENSION DeviceExt,
PFILE_OBJECT FileObject,
BOOLEAN OnlyExclusive ) {
BOOLEAN OnlyExclusive )
{
KIRQL OldIrql;
PLIST_ENTRY ListEntry;
PAFD_ACTIVE_POLL Poll;
@ -135,18 +145,22 @@ VOID KillSelectsForFCB( PAFD_DEVICE_EXTENSION DeviceExt,
KeAcquireSpinLock( &DeviceExt->Lock, &OldIrql );
ListEntry = DeviceExt->Polls.Flink;
while ( ListEntry != &DeviceExt->Polls ) {
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)) ) {
(!OnlyExclusive || (OnlyExclusive && Poll->Exclusive)) )
{
ZeroEvents( PollReq->Handles, PollReq->HandleCount );
SignalSocket( Poll, NULL, PollReq, STATUS_CANCELLED );
}
@ -158,17 +172,17 @@ VOID KillSelectsForFCB( PAFD_DEVICE_EXTENSION DeviceExt,
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;
@ -180,16 +194,20 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
SET_AFD_HANDLES(PollReq,
LockHandles( PollReq->Handles, PollReq->HandleCount ));
if( !AFD_HANDLES(PollReq) ) {
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,
(PFILE_OBJECT)AFD_HANDLES(PollReq)[i].Handle,
@ -199,8 +217,10 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;
@ -209,26 +229,29 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 {
}
else
{
PAFD_ACTIVE_POLL Poll = NULL;
Poll = ExAllocatePool( NonPagedPool, AllocSize );
if (Poll){
if (Poll)
{
Poll->Irp = Irp;
Poll->DeviceExt = DeviceExt;
Poll->Exclusive = Exclusive;
@ -246,7 +269,9 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
Status = STATUS_PENDING;
IoMarkIrpPending( Irp );
(void)IoSetCancelRoutine(Irp, AfdCancelHandler);
} else {
}
else
{
AFD_DbgPrint(MAX_TRACE, ("FIXME: do something with the IRP!\n"));
Status = STATUS_NO_MEMORY;
}
@ -259,33 +284,38 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 ) ) {
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,
if (EventSelectInfo->EventObject && EventSelectInfo->Events)
{
Status = ObReferenceObjectByHandle(
(PVOID)EventSelectInfo->EventObject,
FILE_ALL_ACCESS,
ExEventObjectType,
UserMode,
@ -296,7 +326,9 @@ AfdEventSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
FCB->EventSelect = NULL;
else
FCB->EventSelectTriggers = EventSelectInfo->Events;
} else {
}
else
{
FCB->EventSelect = NULL;
FCB->EventSelectTriggers = 0;
Status = STATUS_SUCCESS;
@ -304,27 +336,28 @@ AfdEventSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 ) ) {
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;
@ -332,29 +365,31 @@ AfdEnumEvents( PDEVICE_OBJECT DeviceObject, PIRP Irp,
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;
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));
if (PollReq->Handles[i].Status)
{
AFD_DbgPrint(MID_TRACE,("Signalling %x with %x\n", FCB, FCB->PollState));
Signalled++;
}
}
@ -362,7 +397,8 @@ static BOOLEAN UpdatePollWithFCB( PAFD_ACTIVE_POLL Poll, PFILE_OBJECT FileObject
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;
@ -377,7 +413,8 @@ VOID PollReeval( PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject ) {
/* Take care of any event select signalling */
FCB = (PAFD_FCB)FileObject->FsContext;
if( !FCB ) {
if (!FCB)
{
KeReleaseSpinLock( &DeviceExt->Lock, OldIrql );
return;
}
@ -385,22 +422,26 @@ VOID PollReeval( PAFD_DEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject ) {
/* Now signal normal select irps */
ThePollEnt = DeviceExt->Polls.Flink;
while( ThePollEnt != &DeviceExt->Polls ) {
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 ) ) {
if (UpdatePollWithFCB(Poll, FileObject))
{
ThePollEnt = ThePollEnt->Flink;
AFD_DbgPrint(MID_TRACE,("Signalling socket\n"));
SignalSocket( Poll, NULL, PollReq, STATUS_SUCCESS );
} else
}
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 );
}

199
drivers/network/afd/afd/write.c
View file

@ -12,10 +12,14 @@
#include "tdiconn.h"
#include "debug.h"
static NTSTATUS NTAPI SendComplete
static
NTSTATUS
NTAPI
SendComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
PVOID Context )
{
NTSTATUS Status = Irp->IoStatus.Status;
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
@ -45,9 +49,11 @@ static NTSTATUS NTAPI SendComplete
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] ) ) {
while (!IsListEmpty( &FCB->PendingIrpList[FUNCTION_SEND]))
{
NextIrpEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_SEND]);
NextIrp = CONTAINING_RECORD(NextIrpEntry, IRP, Tail.Overlay.ListEntry);
NextIrpSp = IoGetCurrentIrpStackLocation( NextIrp );
@ -55,22 +61,26 @@ static NTSTATUS NTAPI SendComplete
NextIrp->IoStatus.Status = STATUS_FILE_CLOSED;
NextIrp->IoStatus.Information = 0;
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
if( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
if (NextIrp->MdlAddress)
UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
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);
@ -81,7 +91,9 @@ static NTSTATUS NTAPI SendComplete
NextIrp->IoStatus.Status = Status;
NextIrp->IoStatus.Information = 0;
if ( NextIrp->MdlAddress ) UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
if (NextIrp->MdlAddress)
UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
@ -96,11 +108,10 @@ static NTSTATUS NTAPI SendComplete
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);
@ -110,7 +121,8 @@ static NTSTATUS NTAPI SendComplete
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],
@ -118,8 +130,7 @@ static NTSTATUS NTAPI SendComplete
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,
@ -144,7 +155,8 @@ static NTSTATUS NTAPI SendComplete
SendReq->BufferCount,
FALSE );
if (NextIrp->MdlAddress) UnlockRequest(NextIrp, NextIrpSp);
if (NextIrp->MdlAddress)
UnlockRequest(NextIrp, NextIrpSp);
IoCompleteRequest(NextIrp, IO_NETWORK_INCREMENT);
}
@ -153,7 +165,8 @@ static NTSTATUS NTAPI SendComplete
}
/* Some data is still waiting */
if( FCB->Send.BytesUsed ) {
if (FCB->Send.BytesUsed)
{
FCB->PollState &= ~AFD_EVENT_SEND;
Status = TdiSend( &FCB->SendIrp.InFlightRequest,
@ -164,7 +177,9 @@ static NTSTATUS NTAPI SendComplete
&FCB->SendIrp.Iosb,
SendComplete,
FCB );
} else {
}
else
{
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
@ -175,10 +190,14 @@ static NTSTATUS NTAPI SendComplete
return STATUS_SUCCESS;
}
static NTSTATUS NTAPI PacketSocketSendComplete
static
NTSTATUS
NTAPI
PacketSocketSendComplete
( PDEVICE_OBJECT DeviceObject,
PIRP Irp,
PVOID Context ) {
PVOID Context)
{
PAFD_FCB FCB = (PAFD_FCB)Context;
PLIST_ENTRY NextIrpEntry;
PIRP NextIrp;
@ -201,17 +220,23 @@ static NTSTATUS NTAPI PacketSocketSendComplete
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] ) ) {
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 ) );
if (NextIrp->MdlAddress)
UnlockRequest( NextIrp, IoGetCurrentIrpStackLocation( NextIrp ) );
(void)IoSetCancelRoutine(NextIrp, NULL);
IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
}
SocketStateUnlock( FCB );
return STATUS_FILE_CLOSED;
}
@ -221,12 +246,15 @@ static NTSTATUS NTAPI PacketSocketSendComplete
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;
@ -234,7 +262,8 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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)
{
@ -243,8 +272,7 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
/* Check that the socket is bound */
if (FCB->State != SOCKET_STATE_BOUND || !FCB->RemoteAddress)
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp,
0 );
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
if (!(SendReq = LockRequest(Irp, IrpSp)))
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
@ -255,14 +283,15 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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,
@ -276,7 +305,8 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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));
@ -296,20 +326,23 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 {
return UnlockAndMaybeComplete(FCB, STATUS_CANT_WAIT, Irp, 0);
}
else
{
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
@ -323,8 +356,10 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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)
{
@ -352,11 +387,11 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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)
@ -367,12 +402,15 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
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 );
}
@ -396,50 +434,55 @@ AfdConnectedSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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 &&
FCB->State != SOCKET_STATE_CREATED)
return UnlockAndMaybeComplete
( FCB, STATUS_INVALID_PARAMETER, Irp, 0 );
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_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))
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,
@ -448,8 +491,7 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
FALSE, FALSE );
if (!SendReq->BufferArray)
return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
Irp, 0 );
return UnlockAndMaybeComplete(FCB, STATUS_ACCESS_VIOLATION, Irp, 0);
AFD_DbgPrint
(MID_TRACE,("RemoteAddress #%d Type %d\n",
@ -463,7 +505,8 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
/* Check the size of the Address given ... */
if( NT_SUCCESS(Status) ) {
if (NT_SUCCESS(Status))
{
FCB->PollState &= ~AFD_EVENT_SEND;
Status = TdiSendDatagram
@ -479,7 +522,8 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
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));
@ -487,6 +531,7 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
* point. */
Information = SendReq->BufferArray[0].len;
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
return UnlockAndMaybeComplete( FCB, Status, Irp, Information );
}

21
drivers/network/tcpip/tcpip/dispatch.c
View file

@ -496,14 +496,16 @@ NTSTATUS DispTdiConnect(
/* Get associated connection endpoint file object. Quit if none exists */
TranContext = IrpSp->FileObject->FsContext;
if (!TranContext) {
if (!TranContext)
{
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
Status = STATUS_INVALID_PARAMETER;
goto done;
}
Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
if (!Connection) {
if (!Connection)
{
TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
Status = STATUS_INVALID_PARAMETER;
goto done;
@ -526,9 +528,11 @@ NTSTATUS DispTdiConnect(
}
done:
if (Status != STATUS_PENDING) {
if (Status != STATUS_PENDING)
{
DispDataRequestComplete(Irp, Status, 0);
} else
}
else
IoMarkIrpPending(Irp);
TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiConnect] TCP Connect returned %08x\n", Status));
@ -560,7 +564,8 @@ NTSTATUS DispTdiDisconnect(
/* Get associated connection endpoint file object. Quit if none exists */
TranContext = IrpSp->FileObject->FsContext;
if (!TranContext) {
if (!TranContext)
{
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
Status = STATUS_INVALID_PARAMETER;
goto done;
@ -583,9 +588,11 @@ NTSTATUS DispTdiDisconnect(
Irp );
done:
if (Status != STATUS_PENDING) {
if (Status != STATUS_PENDING)
{
DispDataRequestComplete(Irp, Status, 0);
} else
}
else
IoMarkIrpPending(Irp);
TI_DbgPrint(MAX_TRACE, ("[TCPIP, DispTdiDisconnect] TCP Disconnect returned %08x\n", Status));

6
lib/drivers/ip/transport/tcp/event.c
View file

@ -185,10 +185,10 @@ TCPAcceptEventHandler(void *arg, struct tcp_pcb *newpcb)
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);
@ -203,6 +203,8 @@ TCPAcceptEventHandler(void *arg, struct tcp_pcb *newpcb)
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);