static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
PIRP Irp,
PFILE_OBJECT NewFileObject,
PAFD_TDI_OBJECT_QELT Qelt ) {
PAFD_FCB FCB = NewFileObject->FsContext;
NTSTATUS Status;
UNREFERENCED_PARAMETER(DeviceExt);
if( !SocketAcquireStateLock( FCB ) )
return LostSocket( Irp );
/* Transfer the connection to the new socket, launch the opening read */
AFD_DbgPrint(MID_TRACE,("Completing a real accept (FCB %p)\n", FCB));
FCB->Connection = Qelt->Object;
if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
FCB->RemoteAddress =
TaCopyTransportAddress( Qelt->ConnInfo->RemoteAddress );
if( !FCB->RemoteAddress )
Status = STATUS_NO_MEMORY;
else
Status = MakeSocketIntoConnection( FCB );
if (NT_SUCCESS(Status))
Status = TdiBuildConnectionInfo(&FCB->ConnectCallInfo, FCB->RemoteAddress);
if (NT_SUCCESS(Status))
Status = TdiBuildConnectionInfo(&FCB->ConnectReturnInfo, FCB->RemoteAddress);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
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_BIND_DATA BindReq;
HANDLE UserHandle = NULL;
UNREFERENCED_PARAMETER(DeviceObject);
AFD_DbgPrint(MID_TRACE,("Called\n"));
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
if( !(BindReq = LockRequest( Irp, IrpSp, FALSE, NULL )) )
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY,
Irp, 0 );
if( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
FCB->LocalAddress = TaCopyTransportAddress( &BindReq->Address );
if( FCB->LocalAddress )
Status = TdiBuildConnectionInfo( &FCB->AddressFrom,
FCB->LocalAddress );
if( NT_SUCCESS(Status) )
Status = WarmSocketForBind( FCB, BindReq->ShareType );
AFD_DbgPrint(MID_TRACE,("FCB->Flags %x\n", FCB->Flags));
if (NT_SUCCESS(Status))
{
Status = ObOpenObjectByPointer(FCB->AddressFile.Object,
0,
NULL,
MAXIMUM_ALLOWED,
*IoFileObjectType,
Irp->RequestorMode,
&UserHandle);
if (NT_SUCCESS(Status))
FCB->State = SOCKET_STATE_BOUND;
}
/* MSAFD relies on us returning the address file handle in the IOSB */
return UnlockAndMaybeComplete( FCB, Status, Irp,
(ULONG_PTR)UserHandle);
}
/* Return the socket object for ths request only if it is a connected or
stream type. */
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_CONNECT_INFO ConnectReq;
AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
UNREFERENCED_PARAMETER(DeviceObject);
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
if( !(ConnectReq = LockRequest( Irp, IrpSp, FALSE, NULL )) )
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp,
0 );
AFD_DbgPrint(MID_TRACE,("Connect request:\n"));
#if 0
OskitDumpBuffer
( (PCHAR)ConnectReq,
IrpSp->Parameters.DeviceIoControl.InputBufferLength );
#endif
if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
{
if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
FCB->RemoteAddress =
TaCopyTransportAddress( &ConnectReq->RemoteAddress );
if( !FCB->RemoteAddress )
Status = STATUS_NO_MEMORY;
else
Status = STATUS_SUCCESS;
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
switch( FCB->State ) {
case SOCKET_STATE_CONNECTED:
Status = STATUS_SUCCESS;
break;
case SOCKET_STATE_CONNECTING:
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_CONNECT );
case SOCKET_STATE_CREATED:
if( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
FCB->LocalAddress =
TaBuildNullTransportAddress( ConnectReq->RemoteAddress.Address[0].AddressType );
if( FCB->LocalAddress ) {
Status = WarmSocketForBind( FCB, AFD_SHARE_WILDCARD );
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 );
/* Drop through to SOCKET_STATE_BOUND */
case SOCKET_STATE_BOUND:
if( FCB->RemoteAddress ) ExFreePool( FCB->RemoteAddress );
FCB->RemoteAddress =
TaCopyTransportAddress( &ConnectReq->RemoteAddress );
if( !FCB->RemoteAddress ) {
Status = STATUS_NO_MEMORY;
break;
}
Status = WarmSocketForConnection( FCB );
if( !NT_SUCCESS(Status) )
break;
if (FCB->ConnectReturnInfo) ExFreePool(FCB->ConnectReturnInfo);
Status = TdiBuildConnectionInfo
( &FCB->ConnectReturnInfo,
&ConnectReq->RemoteAddress );
if( NT_SUCCESS(Status) )
{
if (FCB->ConnectCallInfo) ExFreePool(FCB->ConnectCallInfo);
Status = TdiBuildConnectionInfo(&FCB->ConnectCallInfo,
&ConnectReq->RemoteAddress);
}
else break;
if( NT_SUCCESS(Status) ) {
FCB->ConnectCallInfo->UserData = FCB->ConnectData;
FCB->ConnectCallInfo->UserDataLength = FCB->ConnectDataSize;
FCB->ConnectCallInfo->Options = FCB->ConnectOptions;
FCB->ConnectCallInfo->OptionsLength = FCB->ConnectOptionsSize;
FCB->State = SOCKET_STATE_CONNECTING;
AFD_DbgPrint(MID_TRACE,("Queueing IRP %p\n", Irp));
Status = QueueUserModeIrp( FCB, Irp, FUNCTION_CONNECT );
if (Status == STATUS_PENDING)
{
Status = TdiConnect( &FCB->ConnectIrp.InFlightRequest,
FCB->Connection.Object,
FCB->ConnectCallInfo,
FCB->ConnectReturnInfo,
&FCB->ConnectIrp.Iosb,
StreamSocketConnectComplete,
FCB );
}
if (Status != STATUS_PENDING)
FCB->State = SOCKET_STATE_BOUND;
SocketStateUnlock(FCB);
return Status;
}
break;
default:
AFD_DbgPrint(MIN_TRACE,("Inappropriate socket state %u for connect\n",
FCB->State));
break;
}
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
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_SEND_INFO_UDP SendReq;
KPROCESSOR_MODE LockMode;
UNREFERENCED_PARAMETER(DeviceObject);
AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
/* Check that the socket is bound */
if( FCB->State != SOCKET_STATE_BOUND &&
FCB->State != SOCKET_STATE_CREATED)
{
AFD_DbgPrint(MIN_TRACE,("Invalid socket state\n"));
return UnlockAndMaybeComplete(FCB, STATUS_INVALID_PARAMETER, Irp, 0);
}
if (FCB->SendClosed)
{
AFD_DbgPrint(MIN_TRACE,("No more sends\n"));
return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
}
if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
return UnlockAndMaybeComplete(FCB, STATUS_NO_MEMORY, Irp, 0);
if (FCB->State == SOCKET_STATE_CREATED)
{
if( FCB->LocalAddress ) ExFreePool( FCB->LocalAddress );
FCB->LocalAddress =
TaBuildNullTransportAddress( ((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
Address[0].AddressType );
if( FCB->LocalAddress ) {
Status = WarmSocketForBind( FCB, AFD_SHARE_WILDCARD );
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 );
}
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
SendReq->BufferCount,
NULL, NULL,
FALSE, FALSE, LockMode );
if( !SendReq->BufferArray )
return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
Irp, 0 );
AFD_DbgPrint
(MID_TRACE,("RemoteAddress #%d Type %u\n",
((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
TAAddressCount,
((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress)->
Address[0].AddressType));
Status = TdiBuildConnectionInfo( &TargetAddress,
((PTRANSPORT_ADDRESS)SendReq->TdiConnection.RemoteAddress) );
/* Check the size of the Address given ... */
if( NT_SUCCESS(Status) ) {
FCB->PollState &= ~AFD_EVENT_SEND;
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
if (Status == STATUS_PENDING)
{
TdiSendDatagram(&FCB->SendIrp.InFlightRequest,
FCB->AddressFile.Object,
SendReq->BufferArray[0].buf,
SendReq->BufferArray[0].len,
TargetAddress,
PacketSocketSendComplete,
FCB);
}
ExFreePool(TargetAddress);
SocketStateUnlock(FCB);
return STATUS_PENDING;
}
else
{
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
}
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_SEND_INFO SendReq;
UINT TotalBytesCopied = 0, i, SpaceAvail = 0, BytesCopied, SendLength;
KPROCESSOR_MODE LockMode;
UNREFERENCED_PARAMETER(DeviceObject);
UNREFERENCED_PARAMETER(Short);
AFD_DbgPrint(MID_TRACE,("Called on %p\n", FCB));
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
{
PAFD_SEND_INFO_UDP SendReq;
PTDI_CONNECTION_INFORMATION TargetAddress;
/* Check that the socket is bound */
if( FCB->State != SOCKET_STATE_BOUND || !FCB->RemoteAddress )
{
AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp,
0 );
}
if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
/* Must lock buffers before handing off user data */
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
SendReq->BufferCount,
NULL, NULL,
FALSE, FALSE, LockMode );
if( !SendReq->BufferArray ) {
return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
Irp, 0 );
}
Status = TdiBuildConnectionInfo( &TargetAddress, FCB->RemoteAddress );
if( NT_SUCCESS(Status) ) {
FCB->PollState &= ~AFD_EVENT_SEND;
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
if (Status == STATUS_PENDING)
{
TdiSendDatagram(&FCB->SendIrp.InFlightRequest,
FCB->AddressFile.Object,
SendReq->BufferArray[0].buf,
SendReq->BufferArray[0].len,
TargetAddress,
PacketSocketSendComplete,
FCB);
}
ExFreePool( TargetAddress );
SocketStateUnlock(FCB);
return STATUS_PENDING;
}
else
{
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
}
if (FCB->PollState & AFD_EVENT_CLOSE)
{
AFD_DbgPrint(MIN_TRACE,("Connection reset by remote peer\n"));
/* This is an unexpected remote disconnect */
return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
}
if (FCB->PollState & AFD_EVENT_ABORT)
{
AFD_DbgPrint(MIN_TRACE,("Connection aborted\n"));
/* This is an abortive socket closure on our side */
return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
}
if (FCB->SendClosed)
{
AFD_DbgPrint(MIN_TRACE,("No more sends\n"));
/* This is a graceful send closure */
return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
}
if( !(SendReq = LockRequest( Irp, IrpSp, FALSE, &LockMode )) )
return UnlockAndMaybeComplete
( FCB, STATUS_NO_MEMORY, Irp, 0 );
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
SendReq->BufferCount,
NULL, NULL,
FALSE, FALSE, LockMode );
if( !SendReq->BufferArray ) {
return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
Irp, 0 );
}
AFD_DbgPrint(MID_TRACE,("Socket state %u\n", FCB->State));
if( FCB->State != SOCKET_STATE_CONNECTED ) {
if (!(SendReq->AfdFlags & AFD_OVERLAPPED) &&
((SendReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking))) {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete( FCB, STATUS_CANT_WAIT, Irp, 0 );
} else {
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
}
AFD_DbgPrint(MID_TRACE,("FCB->Send.BytesUsed = %u\n",
FCB->Send.BytesUsed));
SpaceAvail = FCB->Send.Size - FCB->Send.BytesUsed;
AFD_DbgPrint(MID_TRACE,("We can accept %u bytes\n",
SpaceAvail));
/* Count the total transfer size */
SendLength = 0;
for (i = 0; i < SendReq->BufferCount; i++)
{
SendLength += SendReq->BufferArray[i].len;
}
/* Make sure we've got the space */
if (SendLength > SpaceAvail)
{
/* Blocking sockets have to wait here */
if (SendLength <= FCB->Send.Size && !((SendReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking)))
{
FCB->PollState &= ~AFD_EVENT_SEND;
return LeaveIrpUntilLater(FCB, Irp, FUNCTION_SEND);
}
/* Check if we can send anything */
if (SpaceAvail == 0)
{
FCB->PollState &= ~AFD_EVENT_SEND;
/* Non-overlapped sockets will fail if we can send nothing */
if (!(SendReq->AfdFlags & AFD_OVERLAPPED))
{
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete( FCB, STATUS_CANT_WAIT, Irp, 0 );
}
else
{
/* Overlapped sockets just pend */
return LeaveIrpUntilLater(FCB, Irp, FUNCTION_SEND);
}
}
}
for ( i = 0; SpaceAvail > 0 && i < SendReq->BufferCount; i++ )
{
BytesCopied = MIN(SendReq->BufferArray[i].len, SpaceAvail);
AFD_DbgPrint(MID_TRACE,("Copying Buffer %u, %p:%u to %p\n",
i,
SendReq->BufferArray[i].buf,
BytesCopied,
FCB->Send.Window + FCB->Send.BytesUsed));
RtlCopyMemory(FCB->Send.Window + FCB->Send.BytesUsed,
SendReq->BufferArray[i].buf,
BytesCopied);
TotalBytesCopied += BytesCopied;
SpaceAvail -= BytesCopied;
FCB->Send.BytesUsed += BytesCopied;
}
Irp->IoStatus.Information = TotalBytesCopied;
if( TotalBytesCopied == 0 ) {
AFD_DbgPrint(MID_TRACE,("Empty send\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete
( FCB, STATUS_SUCCESS, Irp, TotalBytesCopied );
}
if (SpaceAvail)
{
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
else
{
FCB->PollState &= ~AFD_EVENT_SEND;
}
/* We use the IRP tail for some temporary storage here */
Irp->Tail.Overlay.DriverContext[3] = (PVOID)Irp->IoStatus.Information;
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
if (Status == STATUS_PENDING && !FCB->SendIrp.InFlightRequest)
{
TdiSend(&FCB->SendIrp.InFlightRequest,
FCB->Connection.Object,
0,
FCB->Send.Window,
FCB->Send.BytesUsed,
SendComplete,
FCB);
}
SocketStateUnlock(FCB);
return STATUS_PENDING;
}
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_SEND_INFO SendReq;
UINT TotalBytesCopied = 0, i, SpaceAvail = 0;
BOOLEAN NoSpace = FALSE;
AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
if( FCB->Flags & AFD_ENDPOINT_CONNECTIONLESS )
{
PAFD_SEND_INFO_UDP SendReq;
PTDI_CONNECTION_INFORMATION TargetAddress;
/* Check that the socket is bound */
if( FCB->State != SOCKET_STATE_BOUND || !FCB->RemoteAddress )
{
AFD_DbgPrint(MIN_TRACE,("Invalid parameter\n"));
return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp,
0 );
}
if( !(SendReq = LockRequest( Irp, IrpSp )) )
return UnlockAndMaybeComplete( FCB, STATUS_NO_MEMORY, Irp, 0 );
/* Must lock buffers before handing off user data */
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
SendReq->BufferCount,
NULL, NULL,
FALSE, FALSE );
if( !SendReq->BufferArray ) {
return UnlockAndMaybeComplete( FCB, STATUS_ACCESS_VIOLATION,
Irp, 0 );
}
Status = TdiBuildConnectionInfo( &TargetAddress, FCB->RemoteAddress );
if( NT_SUCCESS(Status) ) {
FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
FCB->PollState &= ~AFD_EVENT_SEND;
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
if (Status == STATUS_PENDING)
{
TdiSendDatagram(&FCB->SendIrp.InFlightRequest,
FCB->AddressFile.Object,
SendReq->BufferArray[0].buf,
SendReq->BufferArray[0].len,
TargetAddress,
&FCB->SendIrp.Iosb,
PacketSocketSendComplete,
FCB);
}
ExFreePool( TargetAddress );
SocketStateUnlock(FCB);
return STATUS_PENDING;
}
else
{
UnlockBuffers(SendReq->BufferArray, SendReq->BufferCount, FALSE);
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
}
}
if (FCB->PollState & AFD_EVENT_CLOSE)
{
AFD_DbgPrint(MIN_TRACE,("Connection reset by remote peer\n"));
/* This is an unexpected remote disconnect */
return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
}
if (FCB->PollState & AFD_EVENT_ABORT)
{
AFD_DbgPrint(MIN_TRACE,("Connection aborted\n"));
/* This is an abortive socket closure on our side */
return UnlockAndMaybeComplete(FCB, FCB->PollStatus[FD_CLOSE_BIT], Irp, 0);
}
if (FCB->SendClosed)
{
AFD_DbgPrint(MIN_TRACE,("No more sends\n"));
/* This is a graceful send closure */
return UnlockAndMaybeComplete(FCB, STATUS_FILE_CLOSED, Irp, 0);
}
if( !(SendReq = LockRequest( Irp, IrpSp )) )
return UnlockAndMaybeComplete
( FCB, STATUS_NO_MEMORY, Irp, TotalBytesCopied );
SendReq->BufferArray = LockBuffers( SendReq->BufferArray,
SendReq->BufferCount,
NULL, NULL,
FALSE, FALSE );
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) || (FCB->NonBlocking) ) {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete
( FCB, STATUS_CANT_WAIT, Irp, 0 );
} else {
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
}
AFD_DbgPrint(MID_TRACE,("FCB->Send.BytesUsed = %d\n",
FCB->Send.BytesUsed));
SpaceAvail = FCB->Send.Size - FCB->Send.BytesUsed;
AFD_DbgPrint(MID_TRACE,("We can accept %d bytes\n",
SpaceAvail));
for( i = 0; FCB->Send.BytesUsed < FCB->Send.Size &&
i < SendReq->BufferCount; i++ ) {
if (SpaceAvail < SendReq->BufferArray[i].len)
{
if (TotalBytesCopied + SendReq->BufferArray[i].len > FCB->Send.Size)
{
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete(FCB, STATUS_BUFFER_OVERFLOW, Irp, 0);
}
SpaceAvail += TotalBytesCopied;
NoSpace = TRUE;
break;
}
AFD_DbgPrint(MID_TRACE,("Copying Buffer %d, %x:%d to %x\n",
i,
SendReq->BufferArray[i].buf,
SendReq->BufferArray[i].len,
FCB->Send.Window + FCB->Send.BytesUsed));
RtlCopyMemory( FCB->Send.Window + FCB->Send.BytesUsed,
SendReq->BufferArray[i].buf,
SendReq->BufferArray[i].len );
TotalBytesCopied += SendReq->BufferArray[i].len;
SpaceAvail -= SendReq->BufferArray[i].len;
}
FCB->EventSelectDisabled &= ~AFD_EVENT_SEND;
if( TotalBytesCopied == 0 ) {
AFD_DbgPrint(MID_TRACE,("Empty send\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete
( FCB, STATUS_SUCCESS, Irp, TotalBytesCopied );
}
if (SpaceAvail)
{
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
else
{
FCB->PollState &= ~AFD_EVENT_SEND;
}
if (!NoSpace)
{
FCB->Send.BytesUsed += TotalBytesCopied;
AFD_DbgPrint(MID_TRACE,("Copied %d bytes\n", TotalBytesCopied));
Status = QueueUserModeIrp(FCB, Irp, FUNCTION_SEND);
if (Status == STATUS_PENDING && !FCB->SendIrp.InFlightRequest)
{
TdiSend(&FCB->SendIrp.InFlightRequest,
FCB->Connection.Object,
0,
FCB->Send.Window,
FCB->Send.BytesUsed,
&FCB->SendIrp.Iosb,
SendComplete,
FCB);
}
SocketStateUnlock(FCB);
return STATUS_PENDING;
}
else
{
FCB->PollState &= ~AFD_EVENT_SEND;
if( (SendReq->AfdFlags & AFD_IMMEDIATE) || (FCB->NonBlocking) ) {
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
return UnlockAndMaybeComplete
( FCB, STATUS_CANT_WAIT, Irp, 0 );
} else {
AFD_DbgPrint(MID_TRACE,("Queuing request\n"));
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_SEND );
}
}
}