//----------------------------------------------------------------
// CImpIRestrictedProcess::RP_WahOpenHandleHelper()
//
// In order to use WPUCreateSocketHandle(), this function must be
// remoted because it creates a file handle...
//
// BUGBUG: Make hSourceProcess and hTargetProcess part of the
// object...
//----------------------------------------------------------------
STDMETHODIMP
CImpIRestrictedProcess::RP_WahOpenHandleHelper( IN DWORD dwTargetPid,
OUT DWORD *pdwHelperHandle,
OUT DWORD *pdwStatus )
{
BOOL fInherit;
DWORD dwSourcePid;
DWORD dwAccess;
DWORD dwOptions;
HANDLE hSourceProcess;
HANDLE hSourceHandle;
HANDLE hTargetProcess;
*pdwHelperHandle = 0;
*pdwStatus = WahOpenHandleHelper(&m_hHelper);
if (*pdwStatus)
{
return NOERROR;
}
// Get a handle to our own process (to be used by DuplicateHandle()).
dwSourcePid = GetCurrentProcessId();
hSourceProcess = OpenProcess( PROCESS_DUP_HANDLE, TRUE, dwSourcePid );
if (!hSourceProcess)
{
*pdwStatus = GetLastError();
WahCloseHandleHelper(m_hHelper);
m_hHelper = 0;
return NOERROR;
}
// Get a handle to the restricted process
hTargetProcess = OpenProcess( PROCESS_DUP_HANDLE, TRUE, dwTargetPid );
if (!hTargetProcess)
{
*pdwStatus = GetLastError();
WahCloseHandleHelper(m_hHelper);
m_hHelper = 0;
CloseHandle(hSourceProcess);
return NOERROR;
}
// Ok, duplicate the helper handle into the restricted client.
dwAccess = 0;
fInherit = FALSE;
dwOptions = DUPLICATE_SAME_ACCESS;
if (!DuplicateHandle(hSourceProcess,
(HANDLE)m_hHelper,
hTargetProcess,
(HANDLE*)pdwHelperHandle,
dwAccess,
fInherit,
dwOptions ))
{
*pdwStatus = GetLastError();
WahCloseHandleHelper(m_hHelper);
m_hHelper = 0;
}
else
{
m_hHelper = (HANDLE)*pdwHelperHandle;
}
// Done with the process handles.
CloseHandle(hSourceProcess);
CloseHandle(hTargetProcess);
return NOERROR;
}
//----------------------------------------------------------------
// CImpIRestrictedProcess::RP_WahCreateSocketHandle()
//
// In order to use WPUCreateSocketHandle(), this function must be
// remoted because it creates a file handle...
//----------------------------------------------------------------
STDMETHODIMP
CImpIRestrictedProcess::RP_WahCreateSocketHandle( IN DWORD dwTargetPid,
IN DWORD dwHelperHandle,
OUT DWORD *pdwSocket,
OUT DWORD *pdwStatus )
{
BOOL fInherit;
DWORD dwSourcePid;
DWORD dwAccess;
DWORD dwOptions;
HANDLE hSourceProcess;
HANDLE hSourceHandle;
HANDLE hTargetProcess;
SOCKET Socket;
*pdwStatus = WahCreateSocketHandle( (HANDLE)m_hHelper,
(SOCKET*)&Socket );
if (*pdwStatus == NO_ERROR)
{
return NOERROR;
}
// Get a handle to our own process (to be used by DuplicateHandle()).
dwSourcePid = GetCurrentProcessId();
hSourceProcess = OpenProcess( PROCESS_DUP_HANDLE, TRUE, dwSourcePid );
if (!hSourceProcess)
{
*pdwStatus = GetLastError();
WahCloseSocketHandle(m_hHelper,Socket);
return NOERROR;
}
// Get a handle to the restricted process
hTargetProcess = OpenProcess( PROCESS_DUP_HANDLE, TRUE, dwTargetPid );
if (!hTargetProcess)
{
*pdwStatus = GetLastError();
WahCloseSocketHandle(m_hHelper,Socket);
CloseHandle(hSourceProcess);
return NOERROR;
}
// Ok, duplicate the helper handle into the restricted client.
dwAccess = 0;
fInherit = FALSE;
dwOptions = DUPLICATE_SAME_ACCESS;
if (!DuplicateHandle(hSourceProcess,
(HANDLE)Socket,
hTargetProcess,
(HANDLE*)pdwSocket,
dwAccess,
fInherit,
dwOptions ))
{
*pdwStatus = GetLastError();
}
// Close local copies of the helper handle and the socket,
// both of these are now in the child process.
WahCloseSocketHandle(m_hHelper,Socket);
WahCloseHandleHelper(m_hHelper);
m_hHelper = 0;
// Done with the process handles.
CloseHandle(hSourceProcess);
CloseHandle(hTargetProcess);
return NOERROR;
}
VOID
WSAAPI
WsProcDelete(IN PWSPROCESS Process)
{
/* Check if we didn't even initialize yet */
if (!Process->LockReady) return;
/* No more current process */
CurrentWsProcess = NULL;
/* If we have a socket table */
if (WsSockHandleTable)
{
/* Enumerate the sockets with a delete callback */
WahEnumerateHandleContexts(WsSockHandleTable,
WsSockDeleteSockets,
Process);
}
/* Close APC Helper */
if (Process->ApcHelper) WahCloseApcHelper(Process->ApcHelper);
/* Close handle helper */
if (Process->HandleHelper) WahCloseHandleHelper(Process->HandleHelper);
/* Check for notification helper */
if (Process->NotificationHelper)
{
/* Close notification helper */
WahCloseNotificationHandleHelper(Process->NotificationHelper);
}
/* Check if we have a protocol catalog*/
if (Process->ProtocolCatalog)
{
/* Enumerate it to clean it up */
WsTcEnumerateCatalogItems(Process->ProtocolCatalog,
CleanupProtocolProviders,
NULL);
/* Delete it */
WsTcDelete(Process->ProtocolCatalog);
Process->ProtocolCatalog = NULL;
}
/* Check if we have a namespace catalog*/
if (Process->NamespaceCatalog)
{
/* Enumerate it to clean it up */
WsNcEnumerateCatalogItems(Process->NamespaceCatalog,
CleanupNamespaceProviders,
NULL);
/* Delete it */
WsNcDelete(Process->NamespaceCatalog);
Process->NamespaceCatalog = NULL;
}
/* Delete the thread lock */
DeleteCriticalSection(&Process->ThreadLock);
/* Delete us */
HeapFree(WsSockHeap, 0, Process);
}
