Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-27 17:10:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

[MSAFD]

Browse source 
- Remove an incorrect change
- Create a new function called TranslateNtStatusError to translate NTSTATUS to winsock error codes
- Call the TranslateNtStatusError in MsafdReturnWithErrno and also use it to translate AFD's poll event error codes
[AFD]
- Track the status for each poll event in our FCB and copy it back when we get an IOCTL_AFD_ENUM_NETWORK_EVENTS IRP
- Remove some useless PollReeval calls

svn path=/trunk/; revision=47377
This commit is contained in:
Cameron Gutman 2010-05-28 03:55:50 +00:00
parent f06be4552d
commit 219cc11d6a
10 changed files with 127 additions and 111 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

129
reactos/dll/win32/msafd/misc/dllmain.c
View file

@ -318,79 +318,86 @@ error:
return INVALID_SOCKET;
}
INT
TranslateNtStatusError(NTSTATUS Status)
{
switch (Status)
{
case STATUS_CANT_WAIT:
return WSAEWOULDBLOCK;
case STATUS_TIMEOUT:
return WSAETIMEDOUT;
case STATUS_SUCCESS:
return NO_ERROR;
case STATUS_FILE_CLOSED:
case STATUS_END_OF_FILE:
return WSAESHUTDOWN;
case STATUS_PENDING:
return WSA_IO_PENDING;
case STATUS_BUFFER_TOO_SMALL:
case STATUS_BUFFER_OVERFLOW:
DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
return WSAEMSGSIZE;
case STATUS_NO_MEMORY:
case STATUS_INSUFFICIENT_RESOURCES:
DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
return WSAENOBUFS;
case STATUS_INVALID_CONNECTION:
DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
return WSAEAFNOSUPPORT;
case STATUS_INVALID_ADDRESS:
DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
return WSAEADDRNOTAVAIL;
case STATUS_REMOTE_NOT_LISTENING:
DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
return WSAECONNREFUSED;
case STATUS_NETWORK_UNREACHABLE:
DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
return WSAENETUNREACH;
case STATUS_INVALID_PARAMETER:
DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
return WSAEINVAL;
case STATUS_CANCELLED:
DbgPrint("MSAFD: STATUS_CANCELLED\n");
return WSA_OPERATION_ABORTED;
default:
DbgPrint("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status);
return WSAENETDOWN;
}
}
DWORD MsafdReturnWithErrno(NTSTATUS Status,
LPINT Errno,
DWORD Received,
LPDWORD ReturnedBytes)
{
if( ReturnedBytes )
*ReturnedBytes = 0;
if( Errno )
if (Errno)
{
switch (Status)
*Errno = TranslateNtStatusError(Status);
if (ReturnedBytes)
{
case STATUS_CANT_WAIT:
*Errno = WSAEWOULDBLOCK;
break;
case STATUS_TIMEOUT:
*Errno = WSAETIMEDOUT;
break;
case STATUS_SUCCESS:
/* Return Number of bytes Read */
if( ReturnedBytes )
if (!*Errno)
*ReturnedBytes = Received;
break;
case STATUS_FILE_CLOSED:
case STATUS_END_OF_FILE:
*Errno = WSAESHUTDOWN;
break;
case STATUS_PENDING:
*Errno = WSA_IO_PENDING;
break;
case STATUS_BUFFER_TOO_SMALL:
case STATUS_BUFFER_OVERFLOW:
DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
*Errno = WSAEMSGSIZE;
break;
case STATUS_NO_MEMORY: /* Fall through to STATUS_INSUFFICIENT_RESOURCES */
case STATUS_INSUFFICIENT_RESOURCES:
DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
*Errno = WSAENOBUFS;
break;
case STATUS_INVALID_CONNECTION:
DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
*Errno = WSAEAFNOSUPPORT;
break;
case STATUS_INVALID_ADDRESS:
DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
*Errno = WSAEADDRNOTAVAIL;
break;
case STATUS_REMOTE_NOT_LISTENING:
DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
*Errno = WSAECONNREFUSED;
break;
case STATUS_NETWORK_UNREACHABLE:
DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
*Errno = WSAENETUNREACH;
break;
case STATUS_INVALID_PARAMETER:
DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
*Errno = WSAEINVAL;
break;
case STATUS_CANCELLED:
DbgPrint("MSAFD: STATUS_CANCELLED\n");
*Errno = WSA_OPERATION_ABORTED;
break;
default:
DbgPrint("MSAFD: Error %x is unknown\n", Status);
*Errno = WSAEINVAL;
break;
else
*ReturnedBytes = 0;
}
}
/* Success */
return Status == STATUS_SUCCESS ? 0 : SOCKET_ERROR;
return Status ? SOCKET_ERROR : 0;
}
/*

18
reactos/dll/win32/msafd/misc/event.c
View file

@ -179,51 +179,51 @@ WSPEnumNetworkEvents(
AFD_DbgPrint(MID_TRACE,("About to touch struct at %x (%d)\n",
lpNetworkEvents, sizeof(*lpNetworkEvents)));
RtlZeroMemory(lpNetworkEvents, sizeof(*lpNetworkEvents));
lpNetworkEvents->lNetworkEvents = 0;
AFD_DbgPrint(MID_TRACE,("Zeroed struct\n"));
/* Set Events to wait for */
if (EnumReq.PollEvents & AFD_EVENT_RECEIVE) {
lpNetworkEvents->lNetworkEvents |= FD_READ;
lpNetworkEvents->iErrorCode[FD_READ_BIT] = EnumReq.EventStatus[FD_READ_BIT];
lpNetworkEvents->iErrorCode[FD_READ_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_READ_BIT]);
}
if (EnumReq.PollEvents & AFD_EVENT_SEND) {
lpNetworkEvents->lNetworkEvents |= FD_WRITE;
lpNetworkEvents->iErrorCode[FD_WRITE_BIT] = EnumReq.EventStatus[FD_WRITE_BIT];
lpNetworkEvents->iErrorCode[FD_WRITE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_WRITE_BIT]);
}
if (EnumReq.PollEvents & AFD_EVENT_OOB_RECEIVE) {
lpNetworkEvents->lNetworkEvents |= FD_OOB;
lpNetworkEvents->iErrorCode[FD_OOB_BIT] = EnumReq.EventStatus[FD_OOB_BIT];
lpNetworkEvents->iErrorCode[FD_OOB_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_OOB_BIT]);
}
if (EnumReq.PollEvents & AFD_EVENT_ACCEPT) {
lpNetworkEvents->lNetworkEvents |= FD_ACCEPT;
lpNetworkEvents->iErrorCode[FD_ACCEPT_BIT] = EnumReq.EventStatus[FD_ACCEPT_BIT];
lpNetworkEvents->iErrorCode[FD_ACCEPT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_ACCEPT_BIT]);
}
if (EnumReq.PollEvents &
(AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL)) {
lpNetworkEvents->lNetworkEvents |= FD_CONNECT;
lpNetworkEvents->iErrorCode[FD_CONNECT_BIT] = EnumReq.EventStatus[FD_CONNECT_BIT];
lpNetworkEvents->iErrorCode[FD_CONNECT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CONNECT_BIT]);
}
if (EnumReq.PollEvents &
(AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE)) {
lpNetworkEvents->lNetworkEvents |= FD_CLOSE;
lpNetworkEvents->iErrorCode[FD_CLOSE_BIT] = EnumReq.EventStatus[FD_CLOSE_BIT];
lpNetworkEvents->iErrorCode[FD_CLOSE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CLOSE_BIT]);
}
if (EnumReq.PollEvents & AFD_EVENT_QOS) {
lpNetworkEvents->lNetworkEvents |= FD_QOS;
lpNetworkEvents->iErrorCode[FD_QOS_BIT] = EnumReq.EventStatus[FD_QOS_BIT];
lpNetworkEvents->iErrorCode[FD_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_QOS_BIT]);
}
if (EnumReq.PollEvents & AFD_EVENT_GROUP_QOS) {
lpNetworkEvents->lNetworkEvents |= FD_GROUP_QOS;
lpNetworkEvents->iErrorCode[FD_GROUP_QOS_BIT] = EnumReq.EventStatus[FD_GROUP_QOS_BIT];
lpNetworkEvents->iErrorCode[FD_GROUP_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_GROUP_QOS_BIT]);
}
if( NT_SUCCESS(Status) ) *lpErrno = 0;

2
reactos/dll/win32/msafd/msafd.h
View file

@ -409,6 +409,8 @@ PSOCKET_INFORMATION GetSocketStructure(
SOCKET Handle
);
INT TranslateNtStatusError( NTSTATUS Status );
VOID DeleteSocketStructure( SOCKET Handle );
int GetSocketInformation(

3
reactos/drivers/network/afd/afd/connect.c
View file

@ -247,6 +247,8 @@ NTSTATUS MakeSocketIntoConnection( PAFD_FCB FCB ) {
if( Status == STATUS_PENDING ) Status = STATUS_SUCCESS;
FCB->PollState |= AFD_EVENT_CONNECT | AFD_EVENT_SEND;
FCB->PollStatus[FD_CONNECT_BIT] = STATUS_SUCCESS;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
return Status;
@ -291,6 +293,7 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
if( !NT_SUCCESS(Irp->IoStatus.Status) ) {
FCB->PollState |= AFD_EVENT_CONNECT_FAIL;
FCB->PollStatus[FD_CONNECT_BIT] = Irp->IoStatus.Status;
AFD_DbgPrint(MID_TRACE,("Going to bound state\n"));
FCB->State = SOCKET_STATE_BOUND;
PollReeval( FCB->DeviceExt, FCB->FileObject );

31
reactos/drivers/network/afd/afd/listen.c
View file

@ -193,11 +193,10 @@ static NTSTATUS NTAPI ListenComplete
/* Trigger a select return if appropriate */
if( !IsListEmpty( &FCB->PendingConnections ) ) {
FCB->PollState |= AFD_EVENT_ACCEPT;
} else {
FCB->PollState &= ~AFD_EVENT_ACCEPT;
}
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_ACCEPT;
SocketStateUnlock( FCB );
@ -293,12 +292,13 @@ NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,
AFD_DbgPrint(MID_TRACE,("Completed a wait for accept\n"));
if ( IsListEmpty( &FCB->PendingConnections ) )
FCB->PollState &= ~AFD_EVENT_ACCEPT;
else
if ( !IsListEmpty( &FCB->PendingConnections ) )
{
FCB->PollState |= AFD_EVENT_ACCEPT;
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_ACCEPT;
SocketStateUnlock( FCB );
return Status;
@ -402,13 +402,12 @@ NTSTATUS AfdAccept( PDEVICE_OBJECT DeviceObject, PIRP Irp,
ExFreePool( PendingConnObj );
if( IsListEmpty( &FCB->PendingConnections ) ) {
FCB->PollState &= ~AFD_EVENT_ACCEPT;
} else {
if( !IsListEmpty( &FCB->PendingConnections ) ) {
FCB->PollState |= AFD_EVENT_ACCEPT;
}
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollStatus[FD_ACCEPT_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_ACCEPT;
SocketStateUnlock( FCB );
return Status;

3
reactos/drivers/network/afd/afd/main.c
View file

@ -314,6 +314,7 @@ AfdCreateSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
/* A datagram socket is always sendable */
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
@ -377,6 +378,7 @@ AfdCloseSocket(PDEVICE_OBJECT DeviceObject, PIRP Irp,
FCB->State = SOCKET_STATE_CLOSED;
FCB->PollState = AFD_EVENT_CLOSE;
FCB->PollStatus[FD_CLOSE_BIT] = STATUS_SUCCESS; //I think we can return success here
PollReeval( FCB->DeviceExt, FCB->FileObject );
InFlightRequest[0] = &FCB->ListenIrp;
@ -542,6 +544,7 @@ AfdDisconnect(PDEVICE_OBJECT DeviceObject, PIRP Irp,
ExFreePool( ConnectionReturnInfo );
FCB->PollState |= AFD_EVENT_DISCONNECT;
FCB->PollStatus[FD_CLOSE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
Status = STATUS_INVALID_PARAMETER;

36
reactos/drivers/network/afd/afd/read.c
View file

@ -46,6 +46,7 @@ static NTSTATUS RefillSocketBuffer( PAFD_FCB FCB ) {
{
/* The socket has been closed */
FCB->PollState |= AFD_EVENT_DISCONNECT;
FCB->PollStatus[FD_CLOSE_BIT] = Status;
FCB->Overread = TRUE;
Status = STATUS_FILE_CLOSED;
}
@ -53,6 +54,7 @@ static NTSTATUS RefillSocketBuffer( PAFD_FCB FCB ) {
{
FCB->Recv.Content = FCB->ReceiveIrp.Iosb.Information;
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
}
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
@ -189,10 +191,10 @@ static NTSTATUS ReceiveActivity( PAFD_FCB FCB, PIRP Irp ) {
if( FCB->Recv.Content ) {
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollState &= ~AFD_EVENT_RECEIVE;
AFD_DbgPrint(MID_TRACE,("RetStatus for irp %x is %x\n", Irp, RetStatus));
@ -538,10 +540,10 @@ PacketSocketRecvComplete(
if( !IsListEmpty( &FCB->DatagramList ) ) {
AFD_DbgPrint(MID_TRACE,("Signalling\n"));
FCB->PollState |= AFD_EVENT_RECEIVE;
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollState &= ~AFD_EVENT_RECEIVE;
if( NT_SUCCESS(Irp->IoStatus.Status) ) {
/* Now relaunch the datagram request */
@ -608,12 +610,12 @@ AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
Status = Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
Irp->IoStatus.Information = DatagramRecv->Len;
if( IsListEmpty( &FCB->DatagramList ) )
FCB->PollState &= ~AFD_EVENT_RECEIVE;
else
if( !IsListEmpty( &FCB->DatagramList ) ) {
FCB->PollState |= AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
@ -624,12 +626,12 @@ AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
( FCB, Irp, DatagramRecv,
(PUINT)&Irp->IoStatus.Information );
if( IsListEmpty( &FCB->DatagramList ) )
FCB->PollState &= ~AFD_EVENT_RECEIVE;
else
if( !IsListEmpty( &FCB->DatagramList ) ) {
FCB->PollState |= AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
FCB->PollStatus[FD_READ_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
} else
FCB->PollState &= ~AFD_EVENT_RECEIVE;
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
@ -640,12 +642,10 @@ AfdPacketSocketReadData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
AFD_DbgPrint(MID_TRACE,("Nonblocking\n"));
Status = STATUS_CANT_WAIT;
FCB->PollState &= ~AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
UnlockBuffers( RecvReq->BufferArray, RecvReq->BufferCount, TRUE );
return UnlockAndMaybeComplete( FCB, Status, Irp, 0 );
} else {
FCB->PollState &= ~AFD_EVENT_RECEIVE;
PollReeval( FCB->DeviceExt, FCB->FileObject );
return LeaveIrpUntilLater( FCB, Irp, FUNCTION_RECV );
}
}

4
reactos/drivers/network/afd/afd/select.c
View file

@ -325,7 +325,9 @@ AfdEnumEvents( PDEVICE_OBJECT DeviceObject, PIRP Irp,
}
EnumReq->PollEvents = FCB->PollState;
RtlZeroMemory( EnumReq->EventStatus, sizeof(EnumReq->EventStatus) );
RtlCopyMemory( EnumReq->EventStatus,
FCB->PollStatus,
sizeof(EnumReq->EventStatus) );
return UnlockAndMaybeComplete( FCB, STATUS_SUCCESS, Irp,
0 );

11
reactos/drivers/network/afd/afd/write.c
View file

@ -142,10 +142,10 @@ static NTSTATUS NTAPI SendComplete
FCB );
} else {
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
}
PollReeval( FCB->DeviceExt, FCB->FileObject );
if( TotalBytesCopied > 0 ) {
UnlockBuffers( SendReq->BufferArray, SendReq->BufferCount, FALSE );
@ -186,6 +186,7 @@ static NTSTATUS NTAPI PacketSocketSendComplete
/* Request is not in flight any longer */
FCB->PollState |= AFD_EVENT_SEND;
FCB->PollStatus[FD_WRITE_BIT] = STATUS_SUCCESS;
PollReeval( FCB->DeviceExt, FCB->FileObject );
if( FCB->State == SOCKET_STATE_CLOSED ) {
@ -391,10 +392,6 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
FCB->PollState &= ~AFD_EVENT_SEND;
PollReeval( FCB->DeviceExt, FCB->FileObject );
/* Check that the socket is bound */
if( FCB->State != SOCKET_STATE_BOUND )
return UnlockAndMaybeComplete
@ -425,6 +422,8 @@ AfdPacketSocketWriteData(PDEVICE_OBJECT DeviceObject, PIRP Irp,
/* Check the size of the Address given ... */
if( NT_SUCCESS(Status) ) {
FCB->PollState &= ~AFD_EVENT_SEND;
Status = TdiSendDatagram
( &FCB->SendIrp.InFlightRequest,
FCB->AddressFile.Object,

1
reactos/drivers/network/afd/include/afd.h
View file

@ -192,6 +192,7 @@ typedef struct _AFD_FCB {
UNICODE_STRING TdiDeviceName;
PVOID Context;
DWORD PollState;
NTSTATUS PollStatus[FD_MAX_EVENTS];
UINT ContextSize;
PVOID ConnectData;
UINT FilledConnectData;