-/* $Id$
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: drivers/net/afd/afd/main.c
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 );
+ if( i && !(i & 0xf) ) DbgPrint( "\n" );
+ if( !(i & 0xf) ) DbgPrint( "%08x: ", (UINT)(Data + i) );
+ DbgPrint( " %02x", Data[i] & 0xff );
}
DbgPrint("\n");
}
NTSTATUS NTAPI
AfdGetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+ PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
if (FCB->DisconnectOptionsSize == 0)
NTSTATUS
NTAPI
AfdSetDisconnectOptions(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+ PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
- PVOID DisconnectOptions = LockRequest(Irp, IrpSp);
+ PVOID DisconnectOptions = LockRequest(Irp, IrpSp, FALSE, NULL);
UINT DisconnectOptionsSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
-
+
if (!DisconnectOptions)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->DisconnectOptions)
{
- ExFreePool(FCB->DisconnectOptions);
+ ExFreePoolWithTag(FCB->DisconnectOptions, TAG_AFD_DISCONNECT_OPTIONS);
FCB->DisconnectOptions = NULL;
FCB->DisconnectOptionsSize = 0;
FCB->FilledDisconnectOptions = 0;
}
- FCB->DisconnectOptions = ExAllocatePool(PagedPool, DisconnectOptionsSize);
- if (!FCB->DisconnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ FCB->DisconnectOptions = ExAllocatePoolWithTag(PagedPool,
+ DisconnectOptionsSize,
+ TAG_AFD_DISCONNECT_OPTIONS);
+
+ if (!FCB->DisconnectOptions)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
RtlCopyMemory(FCB->DisconnectOptions,
DisconnectOptions,
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
- PUINT DisconnectOptionsSize = LockRequest(Irp, IrpSp);
+ PUINT DisconnectOptionsSize = LockRequest(Irp, IrpSp, FALSE, NULL);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
-
+
if (!DisconnectOptionsSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->DisconnectOptions)
{
- ExFreePool(FCB->DisconnectOptions);
+ ExFreePoolWithTag(FCB->DisconnectOptions, TAG_AFD_DISCONNECT_OPTIONS);
FCB->DisconnectOptionsSize = 0;
FCB->FilledDisconnectOptions = 0;
}
- FCB->DisconnectOptions = ExAllocatePool(PagedPool, *DisconnectOptionsSize);
+ FCB->DisconnectOptions = ExAllocatePoolWithTag(PagedPool,
+ *DisconnectOptionsSize,
+ TAG_AFD_DISCONNECT_OPTIONS);
+
if (!FCB->DisconnectOptions) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
FCB->DisconnectOptionsSize = *DisconnectOptionsSize;
NTSTATUS NTAPI
AfdGetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+ PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
if (FCB->DisconnectDataSize == 0)
ASSERT(FCB->DisconnectData);
- if (FCB->FilledDisconnectData < BufferSize) BufferSize = FCB->FilledDisconnectData;
+ if (FCB->FilledDisconnectData < BufferSize)
+ BufferSize = FCB->FilledDisconnectData;
RtlCopyMemory(Irp->UserBuffer,
FCB->DisconnectData,
NTSTATUS
NTAPI
AfdSetDisconnectData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+ PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
- PVOID DisconnectData = LockRequest(Irp, IrpSp);
+ PVOID DisconnectData = LockRequest(Irp, IrpSp, FALSE, NULL);
UINT DisconnectDataSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
-
+
if (!DisconnectData)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->DisconnectData)
{
- ExFreePool(FCB->DisconnectData);
+ ExFreePoolWithTag(FCB->DisconnectData, TAG_AFD_DISCONNECT_DATA);
FCB->DisconnectData = NULL;
FCB->DisconnectDataSize = 0;
FCB->FilledDisconnectData = 0;
}
- FCB->DisconnectData = ExAllocatePool(PagedPool, DisconnectDataSize);
- if (!FCB->DisconnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ FCB->DisconnectData = ExAllocatePoolWithTag(PagedPool,
+ DisconnectDataSize,
+ TAG_AFD_DISCONNECT_DATA);
+
+ if (!FCB->DisconnectData)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
RtlCopyMemory(FCB->DisconnectData,
DisconnectData,
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
- PUINT DisconnectDataSize = LockRequest(Irp, IrpSp);
+ PUINT DisconnectDataSize = LockRequest(Irp, IrpSp, FALSE, NULL);
UINT BufferSize = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
-
+
if (!DisconnectDataSize)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->DisconnectData)
{
- ExFreePool(FCB->DisconnectData);
+ ExFreePoolWithTag(FCB->DisconnectData, TAG_AFD_DISCONNECT_DATA);
FCB->DisconnectDataSize = 0;
FCB->FilledDisconnectData = 0;
}
- FCB->DisconnectData = ExAllocatePool(PagedPool, *DisconnectDataSize);
- if (!FCB->DisconnectData) return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
+ FCB->DisconnectData = ExAllocatePoolWithTag(PagedPool,
+ *DisconnectDataSize,
+ TAG_AFD_DISCONNECT_DATA);
+
+ if (!FCB->DisconnectData)
+ return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
FCB->DisconnectDataSize = *DisconnectDataSize;
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
- PULONG HandleFlags = LockRequest(Irp, IrpSp);
+ PULONG HandleFlags = LockRequest(Irp, IrpSp, TRUE, NULL);
PAFD_TDI_HANDLE_DATA HandleData = Irp->UserBuffer;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
-
+
if (!HandleFlags)
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
static NTSTATUS NTAPI
AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp) {
+ PIO_STACK_LOCATION IrpSp) {
PAFD_FCB FCB;
PFILE_OBJECT FileObject;
PAFD_DEVICE_EXTENSION DeviceExt;
UINT i;
NTSTATUS Status = STATUS_SUCCESS;
- AFD_DbgPrint(MID_TRACE,
- ("AfdCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp));
+ AFD_DbgPrint(MID_TRACE,("AfdCreate(DeviceObject %p Irp %p)\n",
+ DeviceObject, Irp));
DeviceExt = DeviceObject->DeviceExtension;
FileObject = IrpSp->FileObject;
EaInfo = Irp->AssociatedIrp.SystemBuffer;
if( EaInfo ) {
- ConnectInfo = (PAFD_CREATE_PACKET)(EaInfo->EaName + EaInfo->EaNameLength + 1);
- EaInfoValue = (PWCHAR)(((PCHAR)ConnectInfo) + sizeof(AFD_CREATE_PACKET));
+ ConnectInfo = (PAFD_CREATE_PACKET)(EaInfo->EaName + EaInfo->EaNameLength + 1);
+ EaInfoValue = (PWCHAR)(((PCHAR)ConnectInfo) + sizeof(AFD_CREATE_PACKET));
- //EaLength = sizeof(FILE_FULL_EA_INFORMATION) + EaInfo->EaNameLength + EaInfo->EaValueLength;
+ //EaLength = sizeof(FILE_FULL_EA_INFORMATION) + EaInfo->EaNameLength + EaInfo->EaValueLength;
- AFD_DbgPrint(MID_TRACE,("EaInfo: %x, EaInfoValue: %x\n",
- EaInfo, EaInfoValue));
+ AFD_DbgPrint(MID_TRACE,("EaInfo: %p, EaInfoValue: %p\n",
+ EaInfo, EaInfoValue));
}
AFD_DbgPrint(MID_TRACE,("About to allocate the new FCB\n"));
- FCB = ExAllocatePool(NonPagedPool, sizeof(AFD_FCB));
+ FCB = ExAllocatePoolWithTag(NonPagedPool, sizeof(AFD_FCB), TAG_AFD_FCB);
if( FCB == NULL ) {
- Irp->IoStatus.Status = STATUS_NO_MEMORY;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return STATUS_NO_MEMORY;
+ Irp->IoStatus.Status = STATUS_NO_MEMORY;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_NO_MEMORY;
}
- AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %x (FileObject %x Flags %x)\n", FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
+ AFD_DbgPrint(MID_TRACE,("Initializing the new FCB @ %p (FileObject %p Flags %x)\n",
+ FCB, FileObject, ConnectInfo ? ConnectInfo->EndpointFlags : 0));
RtlZeroMemory( FCB, sizeof( *FCB ) );
KeInitializeMutex( &FCB->Mutex, 0 );
for( i = 0; i < MAX_FUNCTIONS; i++ ) {
- InitializeListHead( &FCB->PendingIrpList[i] );
+ InitializeListHead( &FCB->PendingIrpList[i] );
}
InitializeListHead( &FCB->DatagramList );
InitializeListHead( &FCB->PendingConnections );
- AFD_DbgPrint(MID_TRACE,("%x: Checking command channel\n", FCB));
+ AFD_DbgPrint(MID_TRACE,("%p: Checking command channel\n", FCB));
if( ConnectInfo ) {
- FCB->TdiDeviceName.Length = ConnectInfo->SizeOfTransportName;
- FCB->TdiDeviceName.MaximumLength = FCB->TdiDeviceName.Length;
- FCB->TdiDeviceName.Buffer =
- ExAllocatePool( NonPagedPool, FCB->TdiDeviceName.Length );
-
- if( !FCB->TdiDeviceName.Buffer ) {
- ExFreePool(FCB);
- AFD_DbgPrint(MID_TRACE,("Could not copy target string\n"));
- Irp->IoStatus.Status = STATUS_NO_MEMORY;
- IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
- return STATUS_NO_MEMORY;
- }
-
- RtlCopyMemory( FCB->TdiDeviceName.Buffer,
- ConnectInfo->TransportName,
- FCB->TdiDeviceName.Length );
-
- AFD_DbgPrint(MID_TRACE,("Success: %s %wZ\n",
- EaInfo->EaName, &FCB->TdiDeviceName));
+ FCB->TdiDeviceName.Length = ConnectInfo->SizeOfTransportName;
+ FCB->TdiDeviceName.MaximumLength = FCB->TdiDeviceName.Length;
+ FCB->TdiDeviceName.Buffer = ExAllocatePoolWithTag(NonPagedPool,
+ FCB->TdiDeviceName.Length,
+ TAG_AFD_TRANSPORT_ADDRESS);
+
+ if( !FCB->TdiDeviceName.Buffer ) {
+ ExFreePoolWithTag(FCB, TAG_AFD_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;
+ }
+
+ RtlCopyMemory( FCB->TdiDeviceName.Buffer,
+ ConnectInfo->TransportName,
+ FCB->TdiDeviceName.Length );
+
+ AFD_DbgPrint(MID_TRACE,("Success: %s %wZ\n",
+ EaInfo->EaName, &FCB->TdiDeviceName));
} else {
- AFD_DbgPrint(MID_TRACE,("Success: Control connection\n"));
+ AFD_DbgPrint(MID_TRACE,("Success: Control connection\n"));
}
FileObject->FsContext = FCB;
/* It seems that UDP sockets are writable from inception */
if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS ) {
AFD_DbgPrint(MID_TRACE,("Packet oriented socket\n"));
-
- /* A datagram socket is always sendable */
- FCB->PollState |= AFD_EVENT_SEND;
+
+ /* A datagram socket is always sendable */
+ FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
if( !NT_SUCCESS(Status) ) {
- if( FCB->TdiDeviceName.Buffer ) ExFreePool( FCB->TdiDeviceName.Buffer );
- ExFreePool( FCB );
- FileObject->FsContext = NULL;
+ if (FCB->TdiDeviceName.Buffer)
+ {
+ ExFreePoolWithTag(FCB->TdiDeviceName.Buffer, TAG_AFD_TRANSPORT_ADDRESS);
+ }
+ ExFreePoolWithTag(FCB, TAG_AFD_FCB);
+ FileObject->FsContext = NULL;
}
Irp->IoStatus.Status = Status;
UINT Function;
PIRP CurrentIrp;
+ UNREFERENCED_PARAMETER(DeviceObject);
+
if( !SocketAcquireStateLock( FCB ) ) return LostSocket(Irp);
for (Function = 0; Function < MAX_FUNCTIONS; Function++)
static NTSTATUS NTAPI
AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp)
+ PIO_STACK_LOCATION IrpSp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
PAFD_IN_FLIGHT_REQUEST InFlightRequest[IN_FLIGHT_REQUESTS];
PAFD_TDI_OBJECT_QELT Qelt;
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));
if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED;
/* Cancel our pending requests */
for( i = 0; i < IN_FLIGHT_REQUESTS; i++ ) {
- if( InFlightRequest[i]->InFlightRequest ) {
- AFD_DbgPrint(MID_TRACE,("Cancelling in flight irp %d (%x)\n",
- i, InFlightRequest[i]->InFlightRequest));
+ if( InFlightRequest[i]->InFlightRequest ) {
+ AFD_DbgPrint(MID_TRACE,("Cancelling in flight irp %u (%p)\n",
+ i, InFlightRequest[i]->InFlightRequest));
IoCancelIrp(InFlightRequest[i]->InFlightRequest);
- }
+ }
}
KillSelectsForFCB( FCB->DeviceExt, FileObject, FALSE );
ObDereferenceObject(Qelt->Object.Object);
ZwClose(Qelt->Object.Handle);
- ExFreePool(Qelt);
+ ExFreePoolWithTag(Qelt, TAG_AFD_ACCEPT_QUEUE);
}
SocketStateUnlock( FCB );
if( FCB->EventSelect )
ObDereferenceObject( FCB->EventSelect );
- if( FCB->Context )
- ExFreePool( FCB->Context );
+ if (FCB->Context)
+ ExFreePoolWithTag(FCB->Context, TAG_AFD_SOCKET_CONTEXT);
+
+ if (FCB->Recv.Window)
+ ExFreePoolWithTag(FCB->Recv.Window, TAG_AFD_DATA_BUFFER);
- if( FCB->Recv.Window )
- ExFreePool( FCB->Recv.Window );
+ if (FCB->Send.Window)
+ ExFreePoolWithTag(FCB->Send.Window, TAG_AFD_DATA_BUFFER);
- if( FCB->Send.Window )
- ExFreePool( FCB->Send.Window );
+ if (FCB->AddressFrom)
+ ExFreePoolWithTag(FCB->AddressFrom, TAG_AFD_TDI_CONNECTION_INFORMATION);
- if( FCB->AddressFrom )
- ExFreePool( FCB->AddressFrom );
+ if (FCB->ConnectCallInfo)
+ ExFreePoolWithTag(FCB->ConnectCallInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
- if( FCB->ConnectCallInfo )
- ExFreePool( FCB->ConnectCallInfo );
-
- if( FCB->ConnectReturnInfo )
- ExFreePool( FCB->ConnectReturnInfo );
+ if (FCB->ConnectReturnInfo)
+ ExFreePoolWithTag(FCB->ConnectReturnInfo, TAG_AFD_TDI_CONNECTION_INFORMATION);
- if( FCB->ConnectData )
- ExFreePool( FCB->ConnectData );
+ if (FCB->ConnectData)
+ ExFreePoolWithTag(FCB->ConnectData, TAG_AFD_CONNECT_DATA);
- if( FCB->DisconnectData )
- ExFreePool( FCB->DisconnectData );
+ if (FCB->DisconnectData)
+ ExFreePoolWithTag(FCB->DisconnectData, TAG_AFD_DISCONNECT_DATA);
- if( FCB->ConnectOptions )
- ExFreePool( FCB->ConnectOptions );
+ if (FCB->ConnectOptions)
+ ExFreePoolWithTag(FCB->ConnectOptions, TAG_AFD_CONNECT_OPTIONS);
- if( FCB->DisconnectOptions )
- ExFreePool( FCB->DisconnectOptions );
+ if (FCB->DisconnectOptions)
+ ExFreePoolWithTag(FCB->DisconnectOptions, TAG_AFD_DISCONNECT_OPTIONS);
- if( FCB->LocalAddress )
- ExFreePool( FCB->LocalAddress );
+ if (FCB->LocalAddress)
+ ExFreePoolWithTag(FCB->LocalAddress, TAG_AFD_TRANSPORT_ADDRESS);
- if( FCB->RemoteAddress )
- ExFreePool( FCB->RemoteAddress );
+ if (FCB->RemoteAddress)
+ ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
if( FCB->Connection.Object )
{
TdiDisassociateAddressFile(FCB->Connection.Object);
- ObDereferenceObject(FCB->Connection.Object);
+ ObDereferenceObject(FCB->Connection.Object);
}
if( FCB->AddressFile.Object )
- ObDereferenceObject(FCB->AddressFile.Object);
+ ObDereferenceObject(FCB->AddressFile.Object);
if( FCB->AddressFile.Handle != INVALID_HANDLE_VALUE )
{
if (ZwClose(FCB->AddressFile.Handle) == STATUS_INVALID_HANDLE)
{
- DbgPrint("INVALID ADDRESS FILE HANDLE VALUE: %x %x\n", FCB->AddressFile.Handle, FCB->AddressFile.Object);
+ DbgPrint("INVALID ADDRESS FILE HANDLE VALUE: %p %p\n", FCB->AddressFile.Handle, FCB->AddressFile.Object);
}
}
{
if (ZwClose(FCB->Connection.Handle) == STATUS_INVALID_HANDLE)
{
- DbgPrint("INVALID CONNECTION HANDLE VALUE: %x %x\n", FCB->Connection.Handle, FCB->Connection.Object);
+ DbgPrint("INVALID CONNECTION HANDLE VALUE: %p %p\n", FCB->Connection.Handle, FCB->Connection.Object);
}
}
- if( FCB->TdiDeviceName.Buffer )
- ExFreePool(FCB->TdiDeviceName.Buffer);
+ if (FCB->TdiDeviceName.Buffer)
+ {
+ ExFreePoolWithTag(FCB->TdiDeviceName.Buffer, TAG_AFD_TRANSPORT_ADDRESS);
+ }
- ExFreePool(FCB);
+ ExFreePoolWithTag(FCB, TAG_AFD_FCB);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
return STATUS_SUCCESS;
}
+static IO_COMPLETION_ROUTINE DisconnectComplete;
static
NTSTATUS
NTAPI
PAFD_FCB FCB = Context;
PIRP CurrentIrp;
PLIST_ENTRY CurrentEntry;
-
- if( !SocketAcquireStateLock( FCB ) )
+
+ UNREFERENCED_PARAMETER(DeviceObject);
+
+ if (!SocketAcquireStateLock(FCB))
return STATUS_FILE_CLOSED;
-
+
ASSERT(FCB->DisconnectIrp.InFlightRequest == Irp);
FCB->DisconnectIrp.InFlightRequest = NULL;
-
+
ASSERT(FCB->DisconnectPending);
ASSERT((IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest) ||
(FCB->DisconnectFlags & TDI_DISCONNECT_ABORT));
-
+
if (NT_SUCCESS(Irp->IoStatus.Status) && (FCB->DisconnectFlags & TDI_DISCONNECT_RELEASE))
{
FCB->FilledDisconnectData = MIN(FCB->DisconnectDataSize, FCB->ConnectReturnInfo->UserDataLength);
FCB->ConnectReturnInfo->UserData,
FCB->FilledDisconnectData);
}
-
+
FCB->FilledDisconnectOptions = MIN(FCB->DisconnectOptionsSize, FCB->ConnectReturnInfo->OptionsLength);
if (FCB->FilledDisconnectOptions)
{
FCB->FilledDisconnectOptions);
}
}
-
+
FCB->DisconnectPending = FALSE;
-
+
while (!IsListEmpty(&FCB->PendingIrpList[FUNCTION_DISCONNECT]))
{
CurrentEntry = RemoveHeadList(&FCB->PendingIrpList[FUNCTION_DISCONNECT]);
(void)IoSetCancelRoutine(CurrentIrp, NULL);
IoCompleteRequest(CurrentIrp, IO_NETWORK_INCREMENT );
}
-
+
if (!(FCB->DisconnectFlags & TDI_DISCONNECT_RELEASE))
{
/* Signal complete connection closure immediately */
FCB->PollState |= AFD_EVENT_ABORT;
FCB->PollStatus[FD_CLOSE_BIT] = Irp->IoStatus.Status;
+ FCB->LastReceiveStatus = STATUS_FILE_CLOSED;
PollReeval(FCB->DeviceExt, FCB->FileObject);
}
-
+
SocketStateUnlock(FCB);
-
+
return Irp->IoStatus.Status;
}
DoDisconnect(PAFD_FCB FCB)
{
NTSTATUS Status;
-
+
ASSERT(FCB->DisconnectPending);
ASSERT((IsListEmpty(&FCB->PendingIrpList[FUNCTION_SEND]) && !FCB->SendIrp.InFlightRequest) ||
(FCB->DisconnectFlags & TDI_DISCONNECT_ABORT));
-
+
if (FCB->DisconnectIrp.InFlightRequest)
{
return STATUS_PENDING;
FCB->Connection.Object,
&FCB->DisconnectTimeout,
FCB->DisconnectFlags,
- &FCB->DisconnectIrp.Iosb,
DisconnectComplete,
FCB,
FCB->ConnectCallInfo,
{
FCB->DisconnectPending = FALSE;
}
-
+
return Status;
}
static NTSTATUS NTAPI
AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
- PIO_STACK_LOCATION IrpSp) {
+ PIO_STACK_LOCATION IrpSp) {
PFILE_OBJECT FileObject = IrpSp->FileObject;
PAFD_FCB FCB = FileObject->FsContext;
PAFD_DISCONNECT_INFO DisReq;
PLIST_ENTRY CurrentEntry;
PIRP CurrentIrp;
- if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+ UNREFERENCED_PARAMETER(DeviceObject);
+
+ if (!SocketAcquireStateLock(FCB)) return LostSocket(Irp);
+
+ if (!(DisReq = LockRequest(Irp, IrpSp, FALSE, NULL)))
+ return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
+ Irp, 0 );
- if( !(DisReq = LockRequest( Irp, IrpSp )) )
- return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
- Irp, 0 );
-
/* Send direction only */
if ((DisReq->DisconnectType & AFD_DISCONNECT_SEND) &&
!(DisReq->DisconnectType & AFD_DISCONNECT_RECV))
/* Mark us as overread to complete future reads with an error */
FCB->Overread = TRUE;
- /* Set a successful close status to indicate a shutdown on overread */
- FCB->PollStatus[FD_CLOSE_BIT] = STATUS_SUCCESS;
+ /* Set a successful receive status to indicate a shutdown on overread */
+ FCB->LastReceiveStatus = STATUS_SUCCESS;
/* Clear the receive event */
FCB->PollState &= ~AFD_EVENT_RECEIVE;
if (!(FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS))
{
- if( !FCB->ConnectCallInfo )
+ if (!FCB->ConnectCallInfo)
{
AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER,
}
}
}
-
+
FCB->DisconnectFlags = Flags;
FCB->DisconnectTimeout = DisReq->Timeout;
FCB->DisconnectPending = TRUE;
FCB->SendClosed = TRUE;
FCB->PollState &= ~AFD_EVENT_SEND;
-
+
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_DISCONNECT);
if (Status == STATUS_PENDING)
{
/* Go ahead and execute the disconnect because we're ready for it */
Status = DoDisconnect(FCB);
}
-
+
if (Status != STATUS_PENDING)
RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
}
-
+
if (Status == STATUS_PENDING)
{
SocketStateUnlock(FCB);
AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
}
-
- ExFreePool(FCB->RemoteAddress);
-
+
+ ExFreePoolWithTag(FCB->RemoteAddress, TAG_AFD_TRANSPORT_ADDRESS);
+
FCB->RemoteAddress = NULL;
}
-
+
FCB->PollState &= ~AFD_EVENT_SEND;
FCB->SendClosed = TRUE;
}
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
+static DRIVER_DISPATCH AfdDispatch;
static NTSTATUS NTAPI
AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PFILE_OBJECT FileObject = IrpSp->FileObject;
#endif
- AFD_DbgPrint(MID_TRACE,("AfdDispatch: %d\n", IrpSp->MajorFunction));
+ AFD_DbgPrint(MID_TRACE,("AfdDispatch: %u\n", IrpSp->MajorFunction));
if( IrpSp->MajorFunction != IRP_MJ_CREATE) {
- AFD_DbgPrint(MID_TRACE,("FO %x, IrpSp->FO %x\n",
- FileObject, IrpSp->FileObject));
- ASSERT(FileObject == IrpSp->FileObject);
+ AFD_DbgPrint(MID_TRACE,("FO %p, IrpSp->FO %p\n",
+ FileObject, IrpSp->FileObject));
+ ASSERT(FileObject == IrpSp->FileObject);
}
Irp->IoStatus.Information = 0;
switch(IrpSp->MajorFunction)
{
- /* opening and closing handles to the device */
+ /* opening and closing handles to the device */
case IRP_MJ_CREATE:
- /* Mostly borrowed from the named pipe file system */
- return AfdCreateSocket(DeviceObject, Irp, IrpSp);
+ /* Mostly borrowed from the named pipe file system */
+ return AfdCreateSocket(DeviceObject, Irp, IrpSp);
case IRP_MJ_CLOSE:
- /* Ditto the borrowing */
- return AfdCloseSocket(DeviceObject, Irp, IrpSp);
+ /* Ditto the borrowing */
+ return AfdCloseSocket(DeviceObject, Irp, IrpSp);
case IRP_MJ_CLEANUP:
return AfdCleanupSocket(DeviceObject, Irp, IrpSp);
/* write data */
case IRP_MJ_WRITE:
- return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp, TRUE );
+ return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp, TRUE );
/* read data */
case IRP_MJ_READ:
- return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp, TRUE );
+ return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp, TRUE );
case IRP_MJ_DEVICE_CONTROL:
{
- switch( IrpSp->Parameters.DeviceIoControl.IoControlCode ) {
- case IOCTL_AFD_BIND:
- return AfdBindSocket( DeviceObject, Irp, IrpSp );
+ switch( IrpSp->Parameters.DeviceIoControl.IoControlCode ) {
+ case IOCTL_AFD_BIND:
+ return AfdBindSocket( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_CONNECT:
- return AfdStreamSocketConnect( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_CONNECT:
+ return AfdStreamSocketConnect( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_START_LISTEN:
- return AfdListenSocket( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_START_LISTEN:
+ return AfdListenSocket( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_RECV:
- return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp,
- FALSE );
+ case IOCTL_AFD_RECV:
+ return AfdConnectedSocketReadData( DeviceObject, Irp, IrpSp,
+ FALSE );
- case IOCTL_AFD_SELECT:
- return AfdSelect( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_SELECT:
+ return AfdSelect( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_EVENT_SELECT:
- return AfdEventSelect( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_EVENT_SELECT:
+ return AfdEventSelect( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_ENUM_NETWORK_EVENTS:
- return AfdEnumEvents( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_ENUM_NETWORK_EVENTS:
+ return AfdEnumEvents( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_RECV_DATAGRAM:
- return AfdPacketSocketReadData( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_RECV_DATAGRAM:
+ return AfdPacketSocketReadData( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_SEND:
- return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp,
- FALSE );
+ case IOCTL_AFD_SEND:
+ return AfdConnectedSocketWriteData( DeviceObject, Irp, IrpSp,
+ FALSE );
- case IOCTL_AFD_SEND_DATAGRAM:
- return AfdPacketSocketWriteData( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_SEND_DATAGRAM:
+ return AfdPacketSocketWriteData( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_GET_INFO:
- return AfdGetInfo( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_GET_INFO:
+ return AfdGetInfo( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_SET_INFO:
- return AfdSetInfo( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_SET_INFO:
+ return AfdSetInfo( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_GET_CONTEXT_SIZE:
- return AfdGetContextSize( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_GET_CONTEXT_SIZE:
+ return AfdGetContextSize( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_GET_CONTEXT:
- return AfdGetContext( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_GET_CONTEXT:
+ return AfdGetContext( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_SET_CONTEXT:
- return AfdSetContext( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_SET_CONTEXT:
+ return AfdSetContext( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_WAIT_FOR_LISTEN:
- return AfdWaitForListen( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_WAIT_FOR_LISTEN:
+ return AfdWaitForListen( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_ACCEPT:
- return AfdAccept( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_ACCEPT:
+ return AfdAccept( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_DISCONNECT:
- return AfdDisconnect( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_DISCONNECT:
+ return AfdDisconnect( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_GET_SOCK_NAME:
- return AfdGetSockName( DeviceObject, Irp, IrpSp );
+ case IOCTL_AFD_GET_SOCK_NAME:
+ return AfdGetSockName( DeviceObject, Irp, IrpSp );
case IOCTL_AFD_GET_PEER_NAME:
return AfdGetPeerName( DeviceObject, Irp, IrpSp );
- case IOCTL_AFD_GET_CONNECT_DATA:
- return AfdGetConnectData(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_GET_CONNECT_DATA:
+ return AfdGetConnectData(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_CONNECT_DATA:
- return AfdSetConnectData(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_CONNECT_DATA:
+ return AfdSetConnectData(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_DISCONNECT_DATA:
- return AfdSetDisconnectData(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_DISCONNECT_DATA:
+ return AfdSetDisconnectData(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_GET_DISCONNECT_DATA:
- return AfdGetDisconnectData(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_GET_DISCONNECT_DATA:
+ return AfdGetDisconnectData(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_CONNECT_DATA_SIZE:
- return AfdSetConnectDataSize(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_CONNECT_DATA_SIZE:
+ return AfdSetConnectDataSize(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_DISCONNECT_DATA_SIZE:
- return AfdSetDisconnectDataSize(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_DISCONNECT_DATA_SIZE:
+ return AfdSetDisconnectDataSize(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_CONNECT_OPTIONS:
- return AfdSetConnectOptions(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_CONNECT_OPTIONS:
+ return AfdSetConnectOptions(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_DISCONNECT_OPTIONS:
- return AfdSetDisconnectOptions(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_DISCONNECT_OPTIONS:
+ return AfdSetDisconnectOptions(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_GET_CONNECT_OPTIONS:
- return AfdGetConnectOptions(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_GET_CONNECT_OPTIONS:
+ return AfdGetConnectOptions(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_GET_DISCONNECT_OPTIONS:
- return AfdGetDisconnectOptions(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_GET_DISCONNECT_OPTIONS:
+ return AfdGetDisconnectOptions(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE:
- return AfdSetConnectOptionsSize(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_CONNECT_OPTIONS_SIZE:
+ return AfdSetConnectOptionsSize(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE:
- return AfdSetDisconnectOptionsSize(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_SET_DISCONNECT_OPTIONS_SIZE:
+ return AfdSetDisconnectOptionsSize(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_GET_TDI_HANDLES:
- return AfdGetTdiHandles(DeviceObject, Irp, IrpSp);
+ case IOCTL_AFD_GET_TDI_HANDLES:
+ return AfdGetTdiHandles(DeviceObject, Irp, IrpSp);
- case IOCTL_AFD_DEFER_ACCEPT:
- DbgPrint("IOCTL_AFD_DEFER_ACCEPT is UNIMPLEMENTED!\n");
- break;
+ case IOCTL_AFD_DEFER_ACCEPT:
+ DbgPrint("IOCTL_AFD_DEFER_ACCEPT is UNIMPLEMENTED!\n");
+ break;
- case IOCTL_AFD_GET_PENDING_CONNECT_DATA:
- DbgPrint("IOCTL_AFD_GET_PENDING_CONNECT_DATA is UNIMPLEMENTED!\n");
- break;
+ case IOCTL_AFD_GET_PENDING_CONNECT_DATA:
+ DbgPrint("IOCTL_AFD_GET_PENDING_CONNECT_DATA is UNIMPLEMENTED!\n");
+ break;
- case IOCTL_AFD_VALIDATE_GROUP:
- DbgPrint("IOCTL_AFD_VALIDATE_GROUP is UNIMPLEMENTED!\n");
- break;
+ case IOCTL_AFD_VALIDATE_GROUP:
+ DbgPrint("IOCTL_AFD_VALIDATE_GROUP is UNIMPLEMENTED!\n");
+ break;
- default:
- Status = STATUS_NOT_SUPPORTED;
- DbgPrint("Unknown IOCTL (0x%x)\n",
- IrpSp->Parameters.DeviceIoControl.IoControlCode);
- break;
- }
- break;
+ default:
+ Status = STATUS_NOT_SUPPORTED;
+ DbgPrint("Unknown IOCTL (0x%x)\n",
+ IrpSp->Parameters.DeviceIoControl.IoControlCode);
+ break;
+ }
+ break;
}
/* unsupported operations */
default:
{
- Status = STATUS_NOT_IMPLEMENTED;
- AFD_DbgPrint(MIN_TRACE,
- ("Irp: Unknown Major code was %x\n",
- IrpSp->MajorFunction));
- break;
+ Status = STATUS_NOT_IMPLEMENTED;
+ AFD_DbgPrint(MIN_TRACE,
+ ("Irp: Unknown Major code was %x\n",
+ IrpSp->MajorFunction));
+ break;
}
}
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return (Status);
+ return Status;
}
BOOLEAN CheckUnlockExtraBuffers(PAFD_FCB FCB, PIO_STACK_LOCATION IrpSp)
PAFD_RECV_INFO RecvReq;
PAFD_SEND_INFO SendReq;
PAFD_POLL_INFO PollReq;
-
- if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV ||
- IrpSp->MajorFunction == IRP_MJ_READ)
+
+ if (IrpSp->MajorFunction == IRP_MJ_READ)
{
RecvReq = GetLockedData(Irp, IrpSp);
UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
}
- else if ((IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND ||
- IrpSp->MajorFunction == IRP_MJ_WRITE))
+ else if (IrpSp->MajorFunction == IRP_MJ_WRITE)
{
SendReq = GetLockedData(Irp, IrpSp);
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
}
- else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SELECT)
+ else
{
- PollReq = Irp->AssociatedIrp.SystemBuffer;
- ZeroEvents(PollReq->Handles, PollReq->HandleCount);
- SignalSocket(Poll, NULL, PollReq, STATUS_CANCELLED);
- }
+ ASSERT(IrpSp->MajorFunction == IRP_MJ_DEVICE_CONTROL);
+
+ if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_RECV)
+ {
+ RecvReq = GetLockedData(Irp, IrpSp);
+ UnlockBuffers(RecvReq->BufferArray, RecvReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
+ }
+ else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SEND)
+ {
+ SendReq = GetLockedData(Irp, IrpSp);
+ UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, CheckUnlockExtraBuffers(FCB, IrpSp));
+ }
+ else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_AFD_SELECT)
+ {
+ ASSERT(Poll);
+
+ PollReq = Irp->AssociatedIrp.SystemBuffer;
+ ZeroEvents(PollReq->Handles, PollReq->HandleCount);
+ SignalSocket(Poll, NULL, PollReq, STATUS_CANCELLED);
+ }
+ }
}
-VOID NTAPI
+VOID
+NTAPI
AfdCancelHandler(PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PAFD_ACTIVE_POLL Poll;
IoReleaseCancelSpinLock(Irp->CancelIrql);
-
+
if (!SocketAcquireStateLock(FCB))
return;
-
+
switch (IrpSp->MajorFunction)
{
case IRP_MJ_DEVICE_CONTROL:
IoctlCode = IrpSp->Parameters.DeviceIoControl.IoControlCode;
break;
-
+
case IRP_MJ_READ:
IoctlCode = IOCTL_AFD_RECV;
break;
-
+
case IRP_MJ_WRITE:
IoctlCode = IOCTL_AFD_SEND;
break;
-
+
default:
ASSERT(FALSE);
SocketStateUnlock(FCB);
{
case IOCTL_AFD_RECV:
case IOCTL_AFD_RECV_DATAGRAM:
- Function = FUNCTION_RECV;
- break;
+ Function = FUNCTION_RECV;
+ break;
case IOCTL_AFD_SEND:
case IOCTL_AFD_SEND_DATAGRAM:
- Function = FUNCTION_SEND;
- break;
+ Function = FUNCTION_SEND;
+ break;
case IOCTL_AFD_CONNECT:
- Function = FUNCTION_CONNECT;
- break;
+ Function = FUNCTION_CONNECT;
+ break;
case IOCTL_AFD_WAIT_FOR_LISTEN:
- Function = FUNCTION_PREACCEPT;
- break;
+ Function = FUNCTION_PREACCEPT;
+ break;
case IOCTL_AFD_SELECT:
- KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
-
- CurrentEntry = DeviceExt->Polls.Flink;
- while (CurrentEntry != &DeviceExt->Polls)
- {
- Poll = CONTAINING_RECORD(CurrentEntry, AFD_ACTIVE_POLL, ListEntry);
+ KeAcquireSpinLock(&DeviceExt->Lock, &OldIrql);
- if (Irp == Poll->Irp)
+ CurrentEntry = DeviceExt->Polls.Flink;
+ while (CurrentEntry != &DeviceExt->Polls)
{
- CleanupPendingIrp(FCB, Irp, IrpSp, Poll);
- KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
- SocketStateUnlock(FCB);
- return;
- }
- else
- {
- CurrentEntry = CurrentEntry->Flink;
+ Poll = CONTAINING_RECORD(CurrentEntry, AFD_ACTIVE_POLL, ListEntry);
+
+ if (Irp == Poll->Irp)
+ {
+ CleanupPendingIrp(FCB, Irp, IrpSp, Poll);
+ KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
+ SocketStateUnlock(FCB);
+ return;
+ }
+ else
+ {
+ CurrentEntry = CurrentEntry->Flink;
+ }
}
- }
- KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
+ KeReleaseSpinLock(&DeviceExt->Lock, OldIrql);
+
+ SocketStateUnlock(FCB);
+
+ DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (IOCTL_AFD_SELECT)\n");
+ return;
- SocketStateUnlock(FCB);
-
- DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (IOCTL_AFD_SELECT)\n");
- return;
-
case IOCTL_AFD_DISCONNECT:
- Function = FUNCTION_DISCONNECT;
- break;
-
+ Function = FUNCTION_DISCONNECT;
+ break;
+
default:
- ASSERT(FALSE);
- UnlockAndMaybeComplete(FCB, STATUS_CANCELLED, Irp, 0);
- return;
+ ASSERT(FALSE);
+ UnlockAndMaybeComplete(FCB, STATUS_CANCELLED, Irp, 0);
+ return;
}
CurrentEntry = FCB->PendingIrpList[Function].Flink;
CurrentEntry = CurrentEntry->Flink;
}
}
-
+
SocketStateUnlock(FCB);
-
- DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (Function: %d)\n", Function);
+
+ DbgPrint("WARNING!!! IRP cancellation race could lead to a process hang! (Function: %u)\n", Function);
}
+static DRIVER_UNLOAD AfdUnload;
static VOID NTAPI
AfdUnload(PDRIVER_OBJECT DriverObject)
{
+ UNREFERENCED_PARAMETER(DriverObject);
}
NTSTATUS NTAPI
PAFD_DEVICE_EXTENSION DeviceExt;
NTSTATUS Status;
+ UNREFERENCED_PARAMETER(RegistryPath);
/* register driver routines */
DriverObject->MajorFunction[IRP_MJ_CLOSE] = AfdDispatch;
DriverObject->MajorFunction[IRP_MJ_CREATE] = AfdDispatch;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = AfdDispatch;
DriverObject->DriverUnload = AfdUnload;
- Status = IoCreateDevice
- ( DriverObject,
- sizeof(AFD_DEVICE_EXTENSION),
- &wstrDeviceName,
- FILE_DEVICE_NAMED_PIPE,
- 0,
- FALSE,
- &DeviceObject );
+ Status = IoCreateDevice(DriverObject,
+ sizeof(AFD_DEVICE_EXTENSION),
+ &wstrDeviceName,
+ FILE_DEVICE_NAMED_PIPE,
+ 0,
+ FALSE,
+ &DeviceObject);
/* failure */
- if(!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status))
{
- return (Status);
+ return Status;
}
DeviceExt = DeviceObject->DeviceExtension;
KeInitializeSpinLock( &DeviceExt->Lock );
InitializeListHead( &DeviceExt->Polls );
- AFD_DbgPrint(MID_TRACE,("Device created: object %x ext %x\n",
- DeviceObject, DeviceExt));
+ AFD_DbgPrint(MID_TRACE,("Device created: object %p ext %p\n",
+ DeviceObject, DeviceExt));
- return (Status);
+ return Status;
}
/* EOF */
projects / reactos.git / blobdiff