1087 lines
31 KiB
C++
1087 lines
31 KiB
C++
|
/*++
|
|||
|
|
|
|||
|
|
Copyright (C) Microsoft Corporation, 1996 - 1999
|
|||
|
|
|
|||
|
|
Module Name:
|
|||
|
|
|
|||
|
|
Complete.cxx
|
|||
|
|
|
|||
|
|
Abstract:
|
|||
|
|
|
|||
|
|
The place that IO completes
|
|||
|
|
|
|||
|
|
Author:
|
|||
|
|
|
|||
|
|
Mario Goertzel [MarioGo]
|
|||
|
|
|
|||
|
|
Revision History:
|
|||
|
|
|
|||
|
|
MarioGo 3/19/1996 Bits 'n pieces
|
|||
|
|
MarioGo 10/25/1996 Async RPC
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
#include <precomp.hxx>
|
|||
|
|
#include <trans.hxx>
|
|||
|
|
#include <cotrans.hxx>
|
|||
|
|
|
|||
|
|
HANDLE RpcCompletionPort = 0;
|
|||
|
|
HANDLE InactiveRpcCompletionPort = 0;
|
|||
|
|
|
|||
|
|
HANDLE *RpcCompletionPorts;
|
|||
|
|
long *CompletionPortHandleLoads;
|
|||
|
|
|
|||
|
|
BASE_ADDRESS *AddressList = 0;
|
|||
|
|
|
|||
|
|
HANDLE g_NotificationHandle = 0;
|
|||
|
|
LONG g_ListeningForPNPNotifications = 0;
|
|||
|
|
LONG g_NotifyRt = 0;
|
|||
|
|
|
|||
|
|
OVERLAPPED g_Overlapped;
|
|||
|
|
CRITICAL_SECTION AddressListLock;
|
|||
|
|
|
|||
|
|
|
|||
|
|
RPC_STATUS
|
|||
|
|
RPC_ENTRY
|
|||
|
|
COMMON_PostNonIoEvent(
|
|||
|
|
RPC_TRANSPORT_EVENT Event,
|
|||
|
|
DWORD Type,
|
|||
|
|
PVOID Context
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
BOOL b;
|
|||
|
|
int i = 5;
|
|||
|
|
|
|||
|
|
ASSERT(Event != TRANSPORT_POSTED_KEY);
|
|||
|
|
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
// Kick a listening thread
|
|||
|
|
b = PostQueuedCompletionStatus(RpcCompletionPort,
|
|||
|
|
Type,
|
|||
|
|
Event,
|
|||
|
|
(LPOVERLAPPED)Context
|
|||
|
|
);
|
|||
|
|
if (b)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "PostQueuedCompleitonStatus failed %d\n",
|
|||
|
|
GetLastError()));
|
|||
|
|
|
|||
|
|
Sleep(100);
|
|||
|
|
i--;
|
|||
|
|
}
|
|||
|
|
while(i);
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// If this has failed we are out of luck unless something else manages
|
|||
|
|
// to wake up the listen thread.
|
|||
|
|
//
|
|||
|
|
// As of 4/19/96 PostQueuedCompletionStatus will only fail if the handle
|
|||
|
|
// is invalid or the kernel is unable to allocate a small bit of non-paged
|
|||
|
|
// pool. Either way we're toast...
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
ASSERT(b);
|
|||
|
|
|
|||
|
|
if (!b)
|
|||
|
|
{
|
|||
|
|
return(RPC_S_OUT_OF_RESOURCES);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
RPC_STATUS
|
|||
|
|
RPC_ENTRY
|
|||
|
|
COMMON_PostRuntimeEvent(
|
|||
|
|
IN DWORD Type,
|
|||
|
|
IN PVOID Context
|
|||
|
|
)
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
Posts an event to the completion port. This will complete
|
|||
|
|
with an event type of RuntimePosted, event status RPC_S_OK
|
|||
|
|
and event context of Context.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
Context - Context associated with the event
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
RPC_S_OK
|
|||
|
|
|
|||
|
|
RPC_S_OUT_OF_RESOURCES
|
|||
|
|
RPC_S_OUT_OF_MEMORY
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
return(COMMON_PostNonIoEvent(RuntimePosted, Type, Context));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
COMMON_AddressManager(
|
|||
|
|
BASE_ADDRESS *pAddress
|
|||
|
|
)
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
When an address does not have an outstanding connect/accept/recv for some
|
|||
|
|
reason it is added to the AddressList global list of address objects. Listen
|
|||
|
|
threads will try to submit a listen on these as time passed. New addresses
|
|||
|
|
are put onto this list when they are ready to start listening.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
pAddress - An address without an outstanding listen.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
None
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
EnterCriticalSection(&AddressListLock);
|
|||
|
|
|
|||
|
|
if (pAddress->InAddressList == NotInList)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
#if DBG
|
|||
|
|
// The address should not be in the list.
|
|||
|
|
BASE_ADDRESS *pT = AddressList;
|
|||
|
|
while(pT)
|
|||
|
|
{
|
|||
|
|
ASSERT(pT != pAddress);
|
|||
|
|
pT = pT->pNext;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
pAddress->pNext = AddressList;
|
|||
|
|
AddressList = pAddress;
|
|||
|
|
pAddress->InAddressList = InTheList;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
LeaveCriticalSection(&AddressListLock);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void RPC_ENTRY
|
|||
|
|
COMMON_ServerCompleteListen(
|
|||
|
|
IN RPC_TRANSPORT_ADDRESS ThisAddress
|
|||
|
|
)
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
Called on an address once the runtime is really ready to start
|
|||
|
|
processing connections on this address.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
Address - A fully initalized address which the runtime is
|
|||
|
|
ready to start receiving connection on.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
None
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
BASE_ADDRESS *pList = (BASE_ADDRESS *) ThisAddress;
|
|||
|
|
|
|||
|
|
while(pList)
|
|||
|
|
{
|
|||
|
|
COMMON_AddressManager(pList);
|
|||
|
|
pList = pList->pNextAddress;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
COMMON_ListenForPNPNotifications();
|
|||
|
|
|
|||
|
|
// The TRANSPORT message indicates that a new
|
|||
|
|
// address has been added to the AddressList.
|
|||
|
|
|
|||
|
|
COMMON_PostNonIoEvent(TRANSPORT, 0, 0);
|
|||
|
|
|
|||
|
|
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
RPC_STATUS RPC_ENTRY
|
|||
|
|
COMMON_PrepareNewHandle(HANDLE hAdd)
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
Generic wrapper used to add a newly create IO handle to
|
|||
|
|
to the IO completion port.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
hAdd - The handle to be added to the port.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
RPC_S_OK
|
|||
|
|
RPC_S_OUT_OF_MEMORY
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
HANDLE h = CreateIoCompletionPort(hAdd,
|
|||
|
|
RpcCompletionPort,
|
|||
|
|
TRANSPORT_POSTED_KEY,
|
|||
|
|
0);
|
|||
|
|
|
|||
|
|
if (h)
|
|||
|
|
{
|
|||
|
|
ASSERT(h == RpcCompletionPort);
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "CreateIoCompletionPort failed %d\n",
|
|||
|
|
GetLastError()));
|
|||
|
|
|
|||
|
|
ASSERT(GetLastError() == ERROR_NO_SYSTEM_RESOURCES);
|
|||
|
|
|
|||
|
|
return(RPC_S_OUT_OF_MEMORY);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
void
|
|||
|
|
COMMON_RemoveAddress (
|
|||
|
|
IN BASE_ADDRESS *Address
|
|||
|
|
)
|
|||
|
|
/*++
|
|||
|
|
Function Name:COMMON_RemoveAddress
|
|||
|
|
|
|||
|
|
Parameters:
|
|||
|
|
|
|||
|
|
Description:
|
|||
|
|
This function must be called only when AddressListLock is held
|
|||
|
|
Remove address from the address manager list
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
Address->InAddressList = Inactive;
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Close the sockets in the address
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (Address->type & DATAGRAM)
|
|||
|
|
{
|
|||
|
|
DG_DeactivateAddress((WS_DATAGRAM_ENDPOINT *) Address);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
WS_DeactivateAddress((WS_ADDRESS *) Address);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
VOID
|
|||
|
|
RPC_ENTRY
|
|||
|
|
COMMON_StartPnpNotifications (
|
|||
|
|
)
|
|||
|
|
{
|
|||
|
|
ASSERT(RpcCompletionPort);
|
|||
|
|
|
|||
|
|
g_NotifyRt = TRUE;
|
|||
|
|
COMMON_ListenForPNPNotifications();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
VOID
|
|||
|
|
RPC_ENTRY
|
|||
|
|
COMMON_ListenForPNPNotifications (
|
|||
|
|
)
|
|||
|
|
/*++
|
|||
|
|
Function Name:COMMON_ListenForPNPNotifications
|
|||
|
|
|
|||
|
|
Parameters:
|
|||
|
|
|
|||
|
|
Description:
|
|||
|
|
|
|||
|
|
Returns:
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
int retval;
|
|||
|
|
HANDLE h;
|
|||
|
|
|
|||
|
|
if (hWinsock2 == 0)
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// Winsock not loaded, don't need to do any PNP stuff
|
|||
|
|
//
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (InterlockedIncrement(&g_ListeningForPNPNotifications) != 1)
|
|||
|
|
{
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// REVIEW: We may need to provide a mechanism to prevent spinning for lack of
|
|||
|
|
// resources
|
|||
|
|
|
|||
|
|
if (g_NotificationHandle == 0)
|
|||
|
|
{
|
|||
|
|
retval = WSAProviderConfigChange(
|
|||
|
|
&g_NotificationHandle,
|
|||
|
|
0, 0);
|
|||
|
|
if (retval != 0 || g_NotificationHandle == 0)
|
|||
|
|
{
|
|||
|
|
if (g_NotificationHandle)
|
|||
|
|
CloseHandle(g_NotificationHandle);
|
|||
|
|
goto Cleanup;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
h = CreateIoCompletionPort(g_NotificationHandle,
|
|||
|
|
RpcCompletionPort,
|
|||
|
|
NewAddress,
|
|||
|
|
0);
|
|||
|
|
|
|||
|
|
if (h == 0)
|
|||
|
|
{
|
|||
|
|
CloseHandle(g_NotificationHandle);
|
|||
|
|
goto Cleanup;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ASSERT(h == RpcCompletionPort);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// if the previous request is still there, we don't want to submit another one
|
|||
|
|
if (g_Overlapped.Internal != STATUS_PENDING)
|
|||
|
|
{
|
|||
|
|
g_Overlapped.hEvent = 0;
|
|||
|
|
g_Overlapped.Offset = 0;
|
|||
|
|
g_Overlapped.OffsetHigh = 0;
|
|||
|
|
|
|||
|
|
retval = WSAProviderConfigChange(
|
|||
|
|
&g_NotificationHandle,
|
|||
|
|
&g_Overlapped,
|
|||
|
|
0);
|
|||
|
|
if (retval != 0)
|
|||
|
|
{
|
|||
|
|
if (GetLastError() != WSA_IO_PENDING)
|
|||
|
|
{
|
|||
|
|
CloseHandle(g_NotificationHandle);
|
|||
|
|
goto Cleanup;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!TransportProtocol::ResubmitQueriesIfNecessary())
|
|||
|
|
{
|
|||
|
|
CloseHandle(g_NotificationHandle);
|
|||
|
|
goto Cleanup;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
g_ListeningForPNPNotifications = 2;
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
Cleanup:
|
|||
|
|
g_ListeningForPNPNotifications = 0;
|
|||
|
|
g_NotificationHandle = 0;
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "COMMON_ListenForPNPNotifications failed\n"));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
RPC_STATUS
|
|||
|
|
RPC_ENTRY
|
|||
|
|
COMMON_ProcessCalls(
|
|||
|
|
IN INT Timeout,
|
|||
|
|
OUT RPC_TRANSPORT_EVENT *pEvent,
|
|||
|
|
OUT RPC_STATUS *pEventStatus,
|
|||
|
|
IN OUT PVOID *ppEventContext,
|
|||
|
|
OUT UINT *pBufferLength,
|
|||
|
|
OUT BUFFER *pBuffer,
|
|||
|
|
OUT PVOID *ppSourceContext)
|
|||
|
|
/*++
|
|||
|
|
|
|||
|
|
Routine Description:
|
|||
|
|
|
|||
|
|
This routine waits for any async IO to complete for all protocols
|
|||
|
|
within a transport DLL. It maybe called by multiple threads at a
|
|||
|
|
time. A minimum of one thread should always be calling this function
|
|||
|
|
for each DLL.
|
|||
|
|
|
|||
|
|
Note: async clients with no outstanding IO may allow the
|
|||
|
|
last thread to timeout and only call this function again
|
|||
|
|
when a new call is started.
|
|||
|
|
|
|||
|
|
Note: During calls to this API in connection oriented servers
|
|||
|
|
a callback to I_RpcTransServerNewConnection() may occur.
|
|||
|
|
|
|||
|
|
Arguments:
|
|||
|
|
|
|||
|
|
Timeout - -1 - infinite
|
|||
|
|
other - number of milliseconds to wait for IO
|
|||
|
|
|
|||
|
|
pEvent - Set on return to the type of IO event which finished.
|
|||
|
|
|
|||
|
|
pEventStatus - The status of the IO event
|
|||
|
|
|
|||
|
|
ppEventContext - On IN, the handle that the thread should dequeue on.
|
|||
|
|
On output the context of the event
|
|||
|
|
|
|||
|
|
pBufferLength - If the event is successful then the number of
|
|||
|
|
bytes transferred.
|
|||
|
|
|
|||
|
|
pBuffer - If the even is successful then the buffer associated
|
|||
|
|
with the IO.
|
|||
|
|
|
|||
|
|
ppSourceContext - For datagram recvs this is the address
|
|||
|
|
of the sender.
|
|||
|
|
For connection sends this is the SendContext associated
|
|||
|
|
with the IO. For connection recvs it is NULL.
|
|||
|
|
|
|||
|
|
Return Value:
|
|||
|
|
|
|||
|
|
RPC_S_OK - IO completed, see pEventStatus.
|
|||
|
|
|
|||
|
|
RPC_P_TIMEOUT - only if Timeout != INFINITE and is exceeded.
|
|||
|
|
|
|||
|
|
--*/
|
|||
|
|
{
|
|||
|
|
BOOL b;
|
|||
|
|
ULONG_PTR key;
|
|||
|
|
DWORD bytes;
|
|||
|
|
RPC_STATUS status;
|
|||
|
|
LPOVERLAPPED lpOverlapped;
|
|||
|
|
PBASE_OVERLAPPED pBaseOverlapped;
|
|||
|
|
PREQUEST pRequest;
|
|||
|
|
PCONNECTION pConnection;
|
|||
|
|
PADDRESS pAddress;
|
|||
|
|
INT LocalTimeout;
|
|||
|
|
HANDLE hCompletionPortHandle = (HANDLE) *ppEventContext;
|
|||
|
|
DWORD LastError;
|
|||
|
|
|
|||
|
|
ASSERT(RpcCompletionPort);
|
|||
|
|
|
|||
|
|
*pEvent = 0;
|
|||
|
|
*pBuffer = 0;
|
|||
|
|
|
|||
|
|
for(;;)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// Do general house keeping work here. If it appears that more
|
|||
|
|
// house keeping work will be required in the future make
|
|||
|
|
// sure to reduce the LocalTimeout to something < INFINITE.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
LocalTimeout = Timeout;
|
|||
|
|
|
|||
|
|
// House keeping - look for any non-listening addresses and see if we
|
|||
|
|
// can make them listen now. Addresses start in this list and are added
|
|||
|
|
// back into the list if they are unable to submit a listen for some reason.
|
|||
|
|
|
|||
|
|
if (AddressList)
|
|||
|
|
{
|
|||
|
|
EnterCriticalSection(&AddressListLock);
|
|||
|
|
|
|||
|
|
if (AddressList)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
pAddress = (PADDRESS)AddressList;
|
|||
|
|
AddressList = 0;
|
|||
|
|
|
|||
|
|
if (Timeout == INFINITE)
|
|||
|
|
{
|
|||
|
|
// We want to wake up again soon and recheck the AddressList.
|
|||
|
|
LocalTimeout = 7*1000;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
pAddress = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
LeaveCriticalSection(&AddressListLock);
|
|||
|
|
|
|||
|
|
while(pAddress)
|
|||
|
|
{
|
|||
|
|
PADDRESS pNext = (PADDRESS)pAddress->pNext;
|
|||
|
|
pAddress->pNext = 0;
|
|||
|
|
|
|||
|
|
if (pAddress->InAddressList == InTheList)
|
|||
|
|
{
|
|||
|
|
pAddress->InAddressList = NotInList;
|
|||
|
|
pAddress->SubmitListen(pAddress);
|
|||
|
|
}
|
|||
|
|
pAddress = pNext;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!g_ListeningForPNPNotifications)
|
|||
|
|
{
|
|||
|
|
COMMON_ListenForPNPNotifications();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// The good part! Wait for something to happen...
|
|||
|
|
//
|
|||
|
|
b = GetQueuedCompletionStatus(hCompletionPortHandle,
|
|||
|
|
&bytes,
|
|||
|
|
&key,
|
|||
|
|
&lpOverlapped,
|
|||
|
|
LocalTimeout
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
if (!b && !lpOverlapped)
|
|||
|
|
{
|
|||
|
|
// If lpOverlapped is NULL this mean no IO completed.
|
|||
|
|
if ((status = GetLastError()) == STATUS_TIMEOUT)
|
|||
|
|
{
|
|||
|
|
if (Timeout == INFINITE)
|
|||
|
|
{
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
return(RPC_P_TIMEOUT);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "GetQueuedCompletionStatus failed %d\n",
|
|||
|
|
status));
|
|||
|
|
|
|||
|
|
ASSERT(0);
|
|||
|
|
Sleep(1); // Avoid burning all the CPU in case we are hosed.
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//PrintToDebugger("A request arrived at the completion port\n");
|
|||
|
|
if (key != TRANSPORT_POSTED_KEY)
|
|||
|
|
{
|
|||
|
|
if (b)
|
|||
|
|
{
|
|||
|
|
// Internal Non-IO posted event
|
|||
|
|
// Key - The type of event
|
|||
|
|
// lpOverlapped - The context associated with the event
|
|||
|
|
|
|||
|
|
ASSERT( key == RuntimePosted
|
|||
|
|
|| key == TRANSPORT
|
|||
|
|
|| key == NewAddress);
|
|||
|
|
|
|||
|
|
// RuntimePosted events allowed the RPC runtime to wake
|
|||
|
|
// a listening thread with an atbitrary context.
|
|||
|
|
if (key == RuntimePosted)
|
|||
|
|
{
|
|||
|
|
*pEvent = RuntimePosted;
|
|||
|
|
*pEventStatus = RPC_S_OK;
|
|||
|
|
*ppEventContext = lpOverlapped;
|
|||
|
|
*pBufferLength = bytes;
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//
|
|||
|
|
// A protocol was just loaded or unloaded. Take care of it
|
|||
|
|
//
|
|||
|
|
if (key == NewAddress)
|
|||
|
|
{
|
|||
|
|
if (TransportProtocol::HandlePnPStateChange())
|
|||
|
|
{
|
|||
|
|
g_ListeningForPNPNotifications = 0;
|
|||
|
|
*pEvent = NewAddress;
|
|||
|
|
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// REVIEW: Not processing notification handling failures
|
|||
|
|
// may create problems where new protocols, or unloading of
|
|||
|
|
// old ones are ignored. This is not very bad, so we keep
|
|||
|
|
// it simple and ignore it.
|
|||
|
|
g_ListeningForPNPNotifications = 0;
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// TRANSPORT event is posted when a new address
|
|||
|
|
// has been added to the AddressListen. Simply continue
|
|||
|
|
// around the loop.
|
|||
|
|
|
|||
|
|
ASSERT(bytes == 0);
|
|||
|
|
ASSERT(lpOverlapped == 0);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
if (key == NewAddress)
|
|||
|
|
{
|
|||
|
|
g_ListeningForPNPNotifications = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ASSERT(!b || lpOverlapped);
|
|||
|
|
|
|||
|
|
status = RPC_S_OK;
|
|||
|
|
|
|||
|
|
if (!b)
|
|||
|
|
{
|
|||
|
|
pBaseOverlapped = FindOverlapped(lpOverlapped);
|
|||
|
|
pRequest = FindRequest(lpOverlapped);
|
|||
|
|
|
|||
|
|
LastError = GetLastError();
|
|||
|
|
if (( pRequest->type & ADDRESS)
|
|||
|
|
&& (LastError != ERROR_MORE_DATA))
|
|||
|
|
{
|
|||
|
|
VALIDATE(GetLastError())
|
|||
|
|
{
|
|||
|
|
ERROR_NETNAME_DELETED,
|
|||
|
|
ERROR_BAD_NETPATH,
|
|||
|
|
ERROR_NO_SYSTEM_RESOURCES,
|
|||
|
|
ERROR_SEM_TIMEOUT,
|
|||
|
|
ERROR_OPERATION_ABORTED,
|
|||
|
|
ERROR_HOST_UNREACHABLE,
|
|||
|
|
ERROR_NETWORK_UNREACHABLE,
|
|||
|
|
ERROR_UNEXP_NET_ERR,
|
|||
|
|
ERROR_NOT_ENOUGH_QUOTA,
|
|||
|
|
ERROR_BROKEN_PIPE,
|
|||
|
|
ERROR_CONNECTION_ABORTED
|
|||
|
|
} END_VALIDATE;
|
|||
|
|
|
|||
|
|
COMMON_AddressManager((BASE_ADDRESS *)pRequest);
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
switch (LastError)
|
|||
|
|
{
|
|||
|
|
case ERROR_MORE_DATA:
|
|||
|
|
{
|
|||
|
|
// Normal parital read of a connection request
|
|||
|
|
// or an oversized datagram. This is ok, falls
|
|||
|
|
// into the normal path.
|
|||
|
|
|
|||
|
|
status = RPC_P_OVERSIZE_PACKET;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
case ERROR_INVALID_HANDLE:
|
|||
|
|
// Named pipes allows a close to reach the server before
|
|||
|
|
// the read. When this happens the server rejects the read
|
|||
|
|
// with an invalid handle error.
|
|||
|
|
ASSERT(pRequest->id == NMP);
|
|||
|
|
ASSERT(pRequest->fAborted);
|
|||
|
|
|
|||
|
|
// Fall into normal close case.
|
|||
|
|
|
|||
|
|
case ERROR_NETNAME_DELETED:
|
|||
|
|
case ERROR_BROKEN_PIPE:
|
|||
|
|
case ERROR_PIPE_NOT_CONNECTED:
|
|||
|
|
case ERROR_NO_DATA:
|
|||
|
|
case ERROR_SEM_TIMEOUT:
|
|||
|
|
case ERROR_GRACEFUL_DISCONNECT:
|
|||
|
|
case WSAECONNRESET:
|
|||
|
|
case WSAESHUTDOWN:
|
|||
|
|
case WSAECONNABORTED:
|
|||
|
|
case WSAEHOSTDOWN:
|
|||
|
|
case ERROR_CONNECTION_ABORTED:
|
|||
|
|
{
|
|||
|
|
bytes = 0;
|
|||
|
|
ASSERT((pRequest->type & PROTO_MASK) == CONNECTION);
|
|||
|
|
// Will be handled as a close
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
case ERROR_NO_SYSTEM_RESOURCES:
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// This is just like the errors above except that both c/o and datagram requests
|
|||
|
|
// can generate it.
|
|||
|
|
//
|
|||
|
|
if ((pRequest->type & PROTO_MASK) == CONNECTION)
|
|||
|
|
{
|
|||
|
|
bytes = 0;
|
|||
|
|
// Will be handled as a close
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
bytes = 0;
|
|||
|
|
status = ERROR_OPERATION_ABORTED;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
case ERROR_OPERATION_ABORTED:
|
|||
|
|
{
|
|||
|
|
//
|
|||
|
|
// When a thread that issued an I/O dies the operation
|
|||
|
|
// completes with this error.
|
|||
|
|
// There are a couple cases here:
|
|||
|
|
// 1) The IO is datagram in which case we can just
|
|||
|
|
// reissue the I/O on this thread. In an idle
|
|||
|
|
// server eventually all DG I/O will migrate to
|
|||
|
|
// the single listening thread.
|
|||
|
|
// 2) The IO is on a client connection and the
|
|||
|
|
// the client thread has died. In this case
|
|||
|
|
// we need to abort the connection and return
|
|||
|
|
// to the runtime.
|
|||
|
|
// 3) If this happens on an address we have a bug.
|
|||
|
|
// 4) If this happens on a server connection we have a bug.
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
if (pRequest->type & DATAGRAM)
|
|||
|
|
{
|
|||
|
|
// We deal with this in the normal datagram path
|
|||
|
|
ASSERT(bytes == 0);
|
|||
|
|
status = ERROR_OPERATION_ABORTED;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ASSERT((pRequest->type & PROTO_MASK) == CONNECTION);
|
|||
|
|
// zero out the bytes just in case. Sometimes network operations
|
|||
|
|
// return positive byte count on operation aborted
|
|||
|
|
bytes = 0;
|
|||
|
|
|
|||
|
|
// We'll treat this as a connection close on the client.
|
|||
|
|
// REVIEW: Maybe do something better.
|
|||
|
|
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
case ERROR_NETWORK_UNREACHABLE:
|
|||
|
|
case ERROR_HOST_UNREACHABLE:
|
|||
|
|
case ERROR_PORT_UNREACHABLE:
|
|||
|
|
//
|
|||
|
|
// errors coming from ICMP packets to our UDP endpoint.
|
|||
|
|
// Winsock does not present this in a way our async architecture
|
|||
|
|
// can use, so ignore them.
|
|||
|
|
//
|
|||
|
|
if ((pRequest->type & PROTO_MASK) == CONNECTION)
|
|||
|
|
{
|
|||
|
|
bytes = 0;
|
|||
|
|
// Will be handled as a close
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
status = ERROR_OPERATION_ABORTED;
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
{
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "IO failed %lX %d\n",
|
|||
|
|
pRequest,
|
|||
|
|
GetLastError()));
|
|||
|
|
|
|||
|
|
ASSERT(0);
|
|||
|
|
status = RPC_S_OUT_OF_RESOURCES;
|
|||
|
|
// treat as a close
|
|||
|
|
bytes = 0;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// here we actually have a completed IO
|
|||
|
|
pBaseOverlapped = FindOverlapped(lpOverlapped);
|
|||
|
|
pRequest = FindRequest(lpOverlapped);
|
|||
|
|
|
|||
|
|
switch(pRequest->type & PROTO_MASK)
|
|||
|
|
{
|
|||
|
|
case CONNECTION:
|
|||
|
|
//
|
|||
|
|
// Connection IO completed.
|
|||
|
|
//
|
|||
|
|
I_RpcTransUnprotectThread(pBaseOverlapped->thread);
|
|||
|
|
|
|||
|
|
pConnection = (PCONNECTION)pRequest;
|
|||
|
|
|
|||
|
|
// A read or write either completed or failed
|
|||
|
|
|
|||
|
|
*ppEventContext = pConnection;
|
|||
|
|
|
|||
|
|
if (pBaseOverlapped == &pConnection->Read)
|
|||
|
|
{
|
|||
|
|
// Read completed
|
|||
|
|
*ppSourceContext = UlongToPtr(bytes);
|
|||
|
|
|
|||
|
|
if (bytes == 0)
|
|||
|
|
{
|
|||
|
|
*pEvent = pConnection->type | RECEIVE;
|
|||
|
|
pConnection->Abort();
|
|||
|
|
|
|||
|
|
*pEventStatus = RPC_P_CONNECTION_SHUTDOWN;
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
status = pConnection->ProcessRead(bytes,
|
|||
|
|
pBuffer,
|
|||
|
|
pBufferLength);
|
|||
|
|
|
|||
|
|
// N.B. Do not move the reading of the pConnection->type
|
|||
|
|
// before ProcessRead. ProcessRead can change the type based
|
|||
|
|
// on what it reads
|
|||
|
|
*pEvent = pConnection->type | RECEIVE;
|
|||
|
|
|
|||
|
|
if (status != RPC_P_PARTIAL_RECEIVE)
|
|||
|
|
{
|
|||
|
|
ASSERT( status == RPC_P_RECEIVE_FAILED
|
|||
|
|
|| status == RPC_S_OK
|
|||
|
|
|| status == RPC_P_PACKET_CONSUMED);
|
|||
|
|
|
|||
|
|
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Message is not complete, submit the next read and continue.
|
|||
|
|
|
|||
|
|
status = CO_SubmitRead(pConnection);
|
|||
|
|
|
|||
|
|
if (status != RPC_S_OK)
|
|||
|
|
{
|
|||
|
|
ASSERT(status == RPC_P_RECEIVE_FAILED);
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
// Write completed
|
|||
|
|
CO_SEND_CONTEXT *pSend = (CO_SEND_CONTEXT *)pBaseOverlapped;
|
|||
|
|
|
|||
|
|
ASSERT(pSend->Write.pAsyncObject == pConnection);
|
|||
|
|
|
|||
|
|
*pEvent = pConnection->type | SEND;
|
|||
|
|
*ppSourceContext = pSend;
|
|||
|
|
|
|||
|
|
*pBuffer = pSend->pWriteBuffer;
|
|||
|
|
|
|||
|
|
if (bytes == 0)
|
|||
|
|
{
|
|||
|
|
pConnection->Abort();
|
|||
|
|
|
|||
|
|
*pEventStatus = RPC_P_SEND_FAILED;
|
|||
|
|
*pBufferLength = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
status = RPC_S_OK;
|
|||
|
|
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
*pBufferLength = pSend->maxWriteBuffer;
|
|||
|
|
|
|||
|
|
// Netbios client-side writes are sizeof(DWORD) too big since
|
|||
|
|
// they also include the sequence number.
|
|||
|
|
|
|||
|
|
ASSERT( bytes == pSend->maxWriteBuffer
|
|||
|
|
|| ( (bytes == pSend->maxWriteBuffer + sizeof(DWORD))
|
|||
|
|
&& ((pConnection->type & TYPE_MASK) == CLIENT) ) );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case ADDRESS:
|
|||
|
|
{
|
|||
|
|
// ASSERT(bytes == 0);
|
|||
|
|
pAddress = (PADDRESS)pRequest;
|
|||
|
|
PCONNECTION pNewConnection = 0;
|
|||
|
|
|
|||
|
|
status = pAddress->NewConnection(pAddress, &pNewConnection);
|
|||
|
|
|
|||
|
|
if (RPC_S_OK == status)
|
|||
|
|
{
|
|||
|
|
// Opened a connection, now try to submit the first recv.
|
|||
|
|
|
|||
|
|
ASSERT(pNewConnection);
|
|||
|
|
RPC_CONNECTION_TRANSPORT *pInfo;
|
|||
|
|
|
|||
|
|
pInfo = (RPC_CONNECTION_TRANSPORT *)TransportTable[pAddress->id].pInfo;
|
|||
|
|
|
|||
|
|
ASSERT(pInfo->Recv);
|
|||
|
|
|
|||
|
|
status = (pInfo->Recv)(pNewConnection);
|
|||
|
|
|
|||
|
|
if (RPC_S_OK != status)
|
|||
|
|
{
|
|||
|
|
ASSERT(status == RPC_P_RECEIVE_FAILED);
|
|||
|
|
*pEvent = pNewConnection->type | RECEIVE;
|
|||
|
|
*ppEventContext = pNewConnection;
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
return(RPC_S_OK);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Connection has been established or closed, either
|
|||
|
|
// way we can continue around the loop.
|
|||
|
|
}
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case DATAGRAM:
|
|||
|
|
{
|
|||
|
|
BASE_ASYNC_OBJECT *pBase = (BASE_ASYNC_OBJECT*)pRequest;
|
|||
|
|
|
|||
|
|
#ifdef NCADG_MQ_ON
|
|||
|
|
if (pBase->id == MSMQ)
|
|||
|
|
{
|
|||
|
|
// MSMQ (Falcon) datagram path:
|
|||
|
|
MQ_DATAGRAM *pDatagram = (MQ_DATAGRAM*)pRequest;
|
|||
|
|
MQ_DATAGRAM_ENDPOINT *pEndpoint = (MQ_DATAGRAM_ENDPOINT*)pDatagram->pEndpoint;
|
|||
|
|
|
|||
|
|
if (status == RPC_P_OVERSIZE_PACKET)
|
|||
|
|
{
|
|||
|
|
// Data still pending, get it:
|
|||
|
|
status = MQ_ResizePacket( pEndpoint,
|
|||
|
|
(void**)&pDatagram->pAddress,
|
|||
|
|
(unsigned int*)pBufferLength,
|
|||
|
|
pBuffer );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (status == RPC_S_OK)
|
|||
|
|
{
|
|||
|
|
MQ_FillInAddress(pDatagram->pAddress,pDatagram->Read.aMsgPropVar);
|
|||
|
|
|
|||
|
|
*pEvent = pDatagram->type;
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
*ppEventContext = pEndpoint;
|
|||
|
|
// WATCH OUT! MSMQ doesn't return the size in "bytes"
|
|||
|
|
// from GetQueuedCompletionStatus() like everything
|
|||
|
|
// else does! We need to extract the #bytes from the
|
|||
|
|
// message structure.
|
|||
|
|
//
|
|||
|
|
// DON'T: *pBufferLength = bytes;
|
|||
|
|
*pBufferLength = pDatagram->Read.aMsgPropVar[1].ulVal;
|
|||
|
|
*pBuffer = (BUFFER)pDatagram->pPacket;
|
|||
|
|
*ppSourceContext = pDatagram->pAddress;
|
|||
|
|
|
|||
|
|
pDatagram->pPacket = 0;
|
|||
|
|
pDatagram->dwPacketSize = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pDatagram->Busy = 0;
|
|||
|
|
|
|||
|
|
LONG c = InterlockedDecrement(&pEndpoint->cPendingIos);
|
|||
|
|
|
|||
|
|
ASSERT(c >= 0);
|
|||
|
|
|
|||
|
|
if (c == 0)
|
|||
|
|
{
|
|||
|
|
// No pending receives, time to post more. This doesn't
|
|||
|
|
// get hit very often, normally additional recieves are
|
|||
|
|
// after sending a packet. (see DG_SendPacket)
|
|||
|
|
|
|||
|
|
MQ_SubmitReceives(pEndpoint);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (status == RPC_S_OK)
|
|||
|
|
{
|
|||
|
|
return RPC_S_OK;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
#endif
|
|||
|
|
{
|
|||
|
|
// Normal datagram path:
|
|||
|
|
WS_DATAGRAM *pDatagram = (WS_DATAGRAM *)pRequest;
|
|||
|
|
WS_DATAGRAM_ENDPOINT *pEndpoint = (WS_DATAGRAM_ENDPOINT*)pDatagram->pEndpoint;
|
|||
|
|
|
|||
|
|
if (status == RPC_P_OVERSIZE_PACKET)
|
|||
|
|
{
|
|||
|
|
ASSERT(bytes == pDatagram->Packet.len);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ( status == RPC_S_OK
|
|||
|
|
|| status == RPC_P_OVERSIZE_PACKET)
|
|||
|
|
{
|
|||
|
|
// A receive completed
|
|||
|
|
|
|||
|
|
ASSERT(bytes);
|
|||
|
|
|
|||
|
|
*pEvent = pDatagram->type;
|
|||
|
|
*pEventStatus = status;
|
|||
|
|
*ppEventContext = pEndpoint;
|
|||
|
|
*pBufferLength = bytes;
|
|||
|
|
*pBuffer = (BUFFER)pDatagram->Packet.buf;
|
|||
|
|
*ppSourceContext = pDatagram->AddressPair;
|
|||
|
|
|
|||
|
|
ASSERT( pDatagram->Packet.buf );
|
|||
|
|
|
|||
|
|
// Ready the datagram for another IO operation.
|
|||
|
|
pDatagram->Packet.buf = 0;
|
|||
|
|
|
|||
|
|
status = RPC_S_OK;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if DBG
|
|||
|
|
if (status != RPC_S_OK &&
|
|||
|
|
status != ERROR_OPERATION_ABORTED)
|
|||
|
|
{
|
|||
|
|
DbgPrint("RPC: I/O completed with 0x%x\n", status);
|
|||
|
|
|
|||
|
|
ASSERT( 0 );
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
// Do not touch the datagram after this!
|
|||
|
|
pDatagram->Busy = 0;
|
|||
|
|
|
|||
|
|
LONG c = InterlockedDecrement(&pEndpoint->cPendingIos);
|
|||
|
|
|
|||
|
|
ASSERT(c >= 0);
|
|||
|
|
|
|||
|
|
if (c == 0)
|
|||
|
|
{
|
|||
|
|
// No pending receives, time to post more. This doesn't
|
|||
|
|
// get hit very often, normally additional recieves are
|
|||
|
|
// after sending a packet. (see DG_SendPacket)
|
|||
|
|
|
|||
|
|
DG_SubmitReceives(pEndpoint);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (status == RPC_S_OK)
|
|||
|
|
{
|
|||
|
|
return RPC_S_OK;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// Operation aborted, continue around the loop.
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
TransDbgPrint((DPFLTR_RPCPROXY_ID,
|
|||
|
|
DPFLTR_WARNING_LEVEL,
|
|||
|
|
RPCTRANS "Invalid request type: 0x%x (%p)\n",
|
|||
|
|
pRequest->type, pRequest));
|
|||
|
|
|
|||
|
|
ASSERT(0);
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Loop
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ASSERT(0);
|
|||
|
|
return(RPC_S_INTERNAL_ERROR);
|
|||
|
|
}
|
|||
|
|
|