process-win.cpp revision 025753bddaf4d9177cc80dde6963bb4e922c075d
083dd76e9fd7a829b1ed67ffc9003276643e7db1vboxsync/* $Id$ */
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/** @file
083dd76e9fd7a829b1ed67ffc9003276643e7db1vboxsync * IPRT - Process, Windows.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync */
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/*
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * Copyright (C) 2006-2010 Oracle Corporation
85c594c1140f082dd862abde9dc7825137a3d51avboxsync *
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * available from http://www.virtualbox.org. This file is free software;
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * you can redistribute it and/or modify it under the terms of the GNU
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * General Public License (GPL) as published by the Free Software
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
bd8e360cd1db83dcb2694ea9122ce3bc5bae678avboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync *
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * The contents of this file may alternatively be used under the terms
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * of the Common Development and Distribution License Version 1.0
1c94c0a63ba68be1a7b2c640e70d7a06464e4fcavboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * VirtualBox OSE distribution, in which case the provisions of the
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * CDDL are applicable instead of those of the GPL.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync *
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * You may elect to license modified versions of this file under the
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * terms and conditions of either the GPL or the CDDL or both.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/*******************************************************************************
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync* Header Files *
85c594c1140f082dd862abde9dc7825137a3d51avboxsync*******************************************************************************/
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#define LOG_GROUP RTLOGGROUP_PROCESS
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#include <iprt/asm.h> /* hack */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
b29e03c9044019d9c77222336e8f8616052824f5vboxsync#include <Userenv.h>
87b2fb3f8283472ba7010aedbf2b4dc12302155cvboxsync#include <Windows.h>
87b2fb3f8283472ba7010aedbf2b4dc12302155cvboxsync#include <tlhelp32.h>
11a862be79fe123488bccca60c06e92cdbfec6e8vboxsync#include <process.h>
87b2fb3f8283472ba7010aedbf2b4dc12302155cvboxsync#include <errno.h>
e38719852d98638514dba23fbacf53ad11361d6avboxsync#include <Strsafe.h>
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#include <iprt/process.h>
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#include "internal/iprt.h"
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/assert.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/critsect.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/file.h>
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#include <iprt/err.h>
3598f07e0e71a448a04d478320a9ca6314160ff6vboxsync#include <iprt/env.h>
083dd76e9fd7a829b1ed67ffc9003276643e7db1vboxsync#include <iprt/getopt.h>
85c594c1140f082dd862abde9dc7825137a3d51avboxsync#include <iprt/initterm.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/ldr.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/mem.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/once.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/pipe.h>
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync#include <iprt/string.h>
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync#include <iprt/socket.h>
8ab60c04baaf509b2aaae2a260adaf1281aaac03vboxsync
8ab60c04baaf509b2aaae2a260adaf1281aaac03vboxsync
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync/*******************************************************************************
6edb4183bc898fddcd0987b6c5c3903b8246fe45vboxsync* Structures and Typedefs *
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync*******************************************************************************/
85c594c1140f082dd862abde9dc7825137a3d51avboxsynctypedef WINADVAPI BOOL WINAPI FNCREATEPROCESSWITHLOGON(LPCWSTR,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync LPCWSTR,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync LPCWSTR,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync DWORD,
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync LPCWSTR,
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync LPWSTR,
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync DWORD,
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync LPVOID,
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync LPCWSTR,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync LPSTARTUPINFOW,
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync LPPROCESS_INFORMATION);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNCREATEPROCESSWITHLOGON *PFNCREATEPROCESSWITHLOGON;
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsynctypedef DWORD WINAPI FNWTSGETACTIVECONSOLESESSIONID();
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsynctypedef FNWTSGETACTIVECONSOLESESSIONID *PFNWTSGETACTIVECONSOLESESSIONID;
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef HANDLE WINAPI FNCREATETOOLHELP32SNAPSHOT(DWORD, DWORD);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNCREATETOOLHELP32SNAPSHOT *PFNCREATETOOLHELP32SNAPSHOT;
4ad933b349952e43d0b6ce21b3f5e2833ca04e85vboxsync
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsynctypedef BOOL WINAPI FNPROCESS32FIRST(HANDLE, LPPROCESSENTRY32);
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsynctypedef FNPROCESS32FIRST *PFNPROCESS32FIRST;
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsynctypedef BOOL WINAPI FNPROCESS32NEXT(HANDLE, LPPROCESSENTRY32);
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsynctypedef FNPROCESS32NEXT *PFNPROCESS32NEXT;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsynctypedef BOOL WINAPI FNENUMPROCESSES(DWORD*, DWORD, DWORD*);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNENUMPROCESSES *PFNENUMPROCESSES;
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef DWORD FNGETMODULEBASENAME(HANDLE, HMODULE, LPTSTR, DWORD);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNGETMODULEBASENAME *PFNGETMODULEBASENAME;
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync
98da2c2cca8786e117ad93a31c6b2c6c1c3cdc78vboxsynctypedef BOOL WINAPI FNCREATEENVIRONMENTBLOCK(LPVOID *, HANDLE, BOOL);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNCREATEENVIRONMENTBLOCK *PFNCREATEENVIRONMENTBLOCK;
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef BOOL WINAPI FNPFNDESTROYENVIRONMENTBLOCK(LPVOID);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsynctypedef FNPFNDESTROYENVIRONMENTBLOCK *PFNPFNDESTROYENVIRONMENTBLOCK;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsynctypedef BOOL WINAPI FNLOADUSERPROFILEW(HANDLE, LPPROFILEINFOW);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsynctypedef FNLOADUSERPROFILEW *PFNLOADUSERPROFILEW;
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsynctypedef BOOL WINAPI FNUNLOADUSERPROFILE(HANDLE, HANDLE);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsynctypedef FNUNLOADUSERPROFILE *PFNUNLOADUSERPROFILE;
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/*******************************************************************************
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync* Global Variables *
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync*******************************************************************************/
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync/** Init once structure. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic RTONCE g_rtProcWinInitOnce = RTONCE_INITIALIZER;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/** Critical section protecting the process array. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic RTCRITSECT g_CritSect;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/** The number of processes in the array. */
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsyncstatic uint32_t g_cProcesses;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/** The current allocation size. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic uint32_t g_cProcessesAlloc;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/** Array containing the live or non-reaped child processes. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic struct RTPROCWINENTRY
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync{
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync /** The process ID. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync ULONG_PTR pid;
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync /** The process handle. */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync HANDLE hProcess;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync} *g_paProcesses;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/**
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * Clean up the globals.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync *
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * @param enmReason Ignored.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * @param iStatus Ignored.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * @param pvUser Ignored.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic DECLCALLBACK(void) rtProcWinTerm(RTTERMREASON enmReason, int32_t iStatus, void *pvUser)
85c594c1140f082dd862abde9dc7825137a3d51avboxsync{
e38719852d98638514dba23fbacf53ad11361d6avboxsync NOREF(pvUser); NOREF(iStatus); NOREF(enmReason);
e38719852d98638514dba23fbacf53ad11361d6avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync RTCritSectDelete(&g_CritSect);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync size_t i = g_cProcesses;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync while (i-- > 0)
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync CloseHandle(g_paProcesses[i].hProcess);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_paProcesses[i].hProcess = NULL;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync }
85c594c1140f082dd862abde9dc7825137a3d51avboxsync RTMemFree(g_paProcesses);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_paProcesses = NULL;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_cProcesses = 0;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_cProcessesAlloc = 0;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync}
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/**
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * Initialize the globals.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync *
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @returns IPRT status code.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @param pvUser1 Ignored.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @param pvUser2 Ignored.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync */
85c594c1140f082dd862abde9dc7825137a3d51avboxsyncstatic DECLCALLBACK(int32_t) rtProcWinInitOnce(void *pvUser1, void *pvUser2)
85c594c1140f082dd862abde9dc7825137a3d51avboxsync{
85c594c1140f082dd862abde9dc7825137a3d51avboxsync NOREF(pvUser1); NOREF(pvUser2);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_cProcesses = 0;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_cProcessesAlloc = 0;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync g_paProcesses = NULL;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync int rc = RTCritSectInit(&g_CritSect);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync if (RT_SUCCESS(rc))
85c594c1140f082dd862abde9dc7825137a3d51avboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync /** @todo init once, terminate once - this is a generic thing which should
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * have some kind of static and simpler setup! */
85c594c1140f082dd862abde9dc7825137a3d51avboxsync rc = RTTermRegisterCallback(rtProcWinTerm, NULL);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync if (RT_SUCCESS(rc))
85c594c1140f082dd862abde9dc7825137a3d51avboxsync return rc;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync RTCritSectDelete(&g_CritSect);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync }
85c594c1140f082dd862abde9dc7825137a3d51avboxsync return rc;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync}
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/**
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * Gets the process handle for a process from g_paProcesses.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync *
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync * @returns Process handle if found, NULL if not.
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync * @param pid The process to remove (pid).
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync */
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsyncstatic HANDLE rtProcWinFindPid(RTPROCESS pid)
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync{
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync HANDLE hProcess = NULL;
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync RTCritSectEnter(&g_CritSect);
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync uint32_t i = g_cProcesses;
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync while (i-- > 0)
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync if (g_paProcesses[i].pid == pid)
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync {
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync hProcess = g_paProcesses[i].hProcess;
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync break;
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync }
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync RTCritSectLeave(&g_CritSect);
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync return hProcess;
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync}
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync/**
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync * Removes a process from g_paProcesses and closes the process handle.
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync *
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync * @param pid The process to remove (pid).
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync */
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsyncstatic void rtProcWinRemovePid(RTPROCESS pid)
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync{
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync RTCritSectEnter(&g_CritSect);
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync uint32_t i = g_cProcesses;
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync while (i-- > 0)
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync if (g_paProcesses[i].pid == pid)
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync {
999b9efb1c9a95fee642550c525ca0cf7c6f07b5vboxsync HANDLE hProcess = g_paProcesses[i].hProcess;
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync g_cProcesses--;
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync uint32_t cToMove = g_cProcesses - i;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync if (cToMove)
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync memmove(&g_paProcesses[i], &g_paProcesses[i + 1], cToMove * sizeof(g_paProcesses[0]));
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync RTCritSectLeave(&g_CritSect);
6edb4183bc898fddcd0987b6c5c3903b8246fe45vboxsync CloseHandle(hProcess);
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync return;
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync }
85c594c1140f082dd862abde9dc7825137a3d51avboxsync RTCritSectLeave(&g_CritSect);
83b8ea36fb307b6264bc47ae9f7f67b1d32e3388vboxsync}
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/**
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * Adds a process to g_paProcesses.
e38719852d98638514dba23fbacf53ad11361d6avboxsync *
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @returns IPRT status code.
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync * @param pid The process id.
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync * @param hProcess The process handle.
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync */
eb5d68001efb9346c3341aa46f2871b973b47107vboxsyncstatic int rtProcWinAddPid(RTPROCESS pid, HANDLE hProcess)
3598f07e0e71a448a04d478320a9ca6314160ff6vboxsync{
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync RTCritSectEnter(&g_CritSect);
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync uint32_t i = g_cProcesses;
3598f07e0e71a448a04d478320a9ca6314160ff6vboxsync if (i >= g_cProcessesAlloc)
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync {
eb5d68001efb9346c3341aa46f2871b973b47107vboxsync void *pvNew = RTMemRealloc(g_paProcesses, (i + 16) * sizeof(g_paProcesses[0]));
3598f07e0e71a448a04d478320a9ca6314160ff6vboxsync if (RT_UNLIKELY(!pvNew))
85c594c1140f082dd862abde9dc7825137a3d51avboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync RTCritSectLeave(&g_CritSect);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync return VERR_NO_MEMORY;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync }
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync g_paProcesses = (struct RTPROCWINENTRY *)pvNew;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync g_cProcessesAlloc = i + 16;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync }
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync g_paProcesses[i].pid = pid;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync g_paProcesses[i].hProcess = hProcess;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync g_cProcesses = i + 1;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync RTCritSectLeave(&g_CritSect);
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync return VINF_SUCCESS;
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync}
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsyncRTR3DECL(int) RTProcCreate(const char *pszExec, const char * const *papszArgs, RTENV Env, unsigned fFlags, PRTPROCESS pProcess)
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync{
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync return RTProcCreateEx(pszExec, papszArgs, Env, fFlags,
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync NULL, NULL, NULL, /* standard handles */
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync NULL /*pszAsUser*/, NULL /* pszPassword*/,
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync pProcess);
584a4e8a4f886566a96ba14cdaab6e94162545a8vboxsync}
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/**
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * Map some important or much used Windows error codes
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * to our error codes.
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync *
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync * @return Mapped IPRT status code.
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync * @param dwError Windows error code to map to IPRT code.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsyncstatic int rtProcMapErrorCodes(DWORD dwError)
fde449f361029c75f9bf28f145bd1ba7b36a9c77vboxsync{
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync int rc;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync switch (dwError)
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync {
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync case ERROR_NOACCESS:
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync case ERROR_PRIVILEGE_NOT_HELD:
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync rc = VERR_PERMISSION_DENIED;
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync break;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync case ERROR_PASSWORD_EXPIRED:
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync case ERROR_ACCOUNT_RESTRICTION: /* See: http://support.microsoft.com/kb/303846/ */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync case ERROR_PASSWORD_RESTRICTION:
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync rc = VERR_AUTHENTICATION_FAILURE;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync break;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync default:
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync /* Could trigger a debug assertion! */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync rc = RTErrConvertFromWin32(dwError);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync break;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync }
85c594c1140f082dd862abde9dc7825137a3d51avboxsync return rc;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync}
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync/**
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * Get the process token (not the process handle like the name might indicate)
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * of the process indicated by @a dwPID if the @a pSID matches.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync *
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * @returns IPRT status code.
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync *
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync * @param dwPID The process identifier.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @param pSID The secure identifier of the user.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * @param phToken Where to return the token handle - duplicate,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * caller closes it on success.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync */
85c594c1140f082dd862abde9dc7825137a3d51avboxsyncstatic int rtProcGetProcessHandle(DWORD dwPID, PSID pSID, PHANDLE phToken)
e38719852d98638514dba23fbacf53ad11361d6avboxsync{
85c594c1140f082dd862abde9dc7825137a3d51avboxsync AssertPtr(pSID);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync AssertPtr(phToken);
e38719852d98638514dba23fbacf53ad11361d6avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync DWORD dwErr;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync BOOL fRc;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync bool fFound = false;
e38719852d98638514dba23fbacf53ad11361d6avboxsync HANDLE hProc = OpenProcess(MAXIMUM_ALLOWED, TRUE, dwPID);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync if (hProc != NULL)
e38719852d98638514dba23fbacf53ad11361d6avboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync HANDLE hTokenProc;
85c594c1140f082dd862abde9dc7825137a3d51avboxsync fRc = OpenProcessToken(hProc,
0c1bdc5adae416967cb64e09f8ec81a5b77fe31dvboxsync TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY | TOKEN_DUPLICATE
85c594c1140f082dd862abde9dc7825137a3d51avboxsync | TOKEN_ASSIGN_PRIMARY | TOKEN_ADJUST_SESSIONID | TOKEN_READ | TOKEN_WRITE,
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync &hTokenProc);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync if (fRc)
16a9c73495bd644adca2ffe9567c3b2a72d7b94dvboxsync {
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync DWORD dwSize = 0;
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync fRc = GetTokenInformation(hTokenProc, TokenUser, NULL, 0, &dwSize);
4cf22962b49e1056d0424cbe6736fee615e296efvboxsync if (!fRc)
4cf22962b49e1056d0424cbe6736fee615e296efvboxsync dwErr = GetLastError();
4cf22962b49e1056d0424cbe6736fee615e296efvboxsync if ( !fRc
4cf22962b49e1056d0424cbe6736fee615e296efvboxsync && dwErr == ERROR_INSUFFICIENT_BUFFER
16a9c73495bd644adca2ffe9567c3b2a72d7b94dvboxsync && dwSize > 0)
16a9c73495bd644adca2ffe9567c3b2a72d7b94dvboxsync {
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync PTOKEN_USER pTokenUser = (PTOKEN_USER)RTMemAlloc(dwSize);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync AssertPtrReturn(pTokenUser, VERR_NO_MEMORY); /** @todo r=bird: Leaking handles when we're out of memory... */
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync RT_ZERO(*pTokenUser);
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync if ( GetTokenInformation(hTokenProc,
f6b7aa2d424718f1bf8ca45a37b219b986f1024bvboxsync TokenUser,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync (LPVOID)pTokenUser,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync dwSize,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync &dwSize))
e38719852d98638514dba23fbacf53ad11361d6avboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync if ( IsValidSid(pTokenUser->User.Sid)
85c594c1140f082dd862abde9dc7825137a3d51avboxsync && EqualSid(pTokenUser->User.Sid, pSID))
85c594c1140f082dd862abde9dc7825137a3d51avboxsync {
85c594c1140f082dd862abde9dc7825137a3d51avboxsync if (DuplicateTokenEx(hTokenProc, MAXIMUM_ALLOWED,
85c594c1140f082dd862abde9dc7825137a3d51avboxsync NULL, SecurityIdentification, TokenPrimary, phToken))
85c594c1140f082dd862abde9dc7825137a3d51avboxsync {
b29e03c9044019d9c77222336e8f8616052824f5vboxsync /*
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync * So we found the process instance which belongs to the user we want to
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync * to run our new process under. This duplicated token will be used for
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync * the actual CreateProcessAsUserW() call then.
11a862be79fe123488bccca60c06e92cdbfec6e8vboxsync */
6e94cf9c6334b6d8e3cd33afe7084e0048fe7c8evboxsync fFound = true;
6e94cf9c6334b6d8e3cd33afe7084e0048fe7c8evboxsync }
6e94cf9c6334b6d8e3cd33afe7084e0048fe7c8evboxsync else
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync dwErr = GetLastError();
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync }
11a862be79fe123488bccca60c06e92cdbfec6e8vboxsync }
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync else
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync dwErr = GetLastError();
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync RTMemFree(pTokenUser);
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync }
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync else
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync dwErr = GetLastError();
1c8130d3c423590046a8ed4f3059de38ac5dcc14vboxsync CloseHandle(hTokenProc);
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync }
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync else
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync dwErr = GetLastError();
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync CloseHandle(hProc);
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync }
463d00559e51c6e08ccc9f5a77d2ee6d122b6e8cvboxsync else
34822e8b7d00c04a0bc98c0d1a565a00d9bb1fd9vboxsync dwErr = GetLastError();
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync if (fFound)
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync return VINF_SUCCESS;
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync if (dwErr != NO_ERROR)
507ebf9b3b77c84000a55645867db6617b5324bcvboxsync return RTErrConvertFromWin32(dwErr);
85c594c1140f082dd862abde9dc7825137a3d51avboxsync return VERR_NOT_FOUND; /* No error occurred, but we didn't find the right process. */
85c594c1140f082dd862abde9dc7825137a3d51avboxsync}
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync
85c594c1140f082dd862abde9dc7825137a3d51avboxsync/**
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * Finds a one of the processes in @a papszNames running with user @a pSID and
85c594c1140f082dd862abde9dc7825137a3d51avboxsync * returns a duplicate handle to its token.
85c594c1140f082dd862abde9dc7825137a3d51avboxsync *
* @returns Success indicator.
* @param papszNames The process candidates, in prioritized order.
* @param pSid The secure identifier of the user.
* @param phToken Where to return the token handle - duplicate,
* caller closes it on success.
*/
static bool rtProcFindProcessByName(const char * const *papszNames, PSID pSid, PHANDLE phToken)
{
AssertPtr(papszNames);
AssertPtr(pSid);
AssertPtr(phToken);
DWORD dwErr = NO_ERROR;
bool fFound = false;
/*
* On modern systems (W2K+) try the Toolhelp32 API first; this is more stable
* and reliable. Fallback to EnumProcess on NT4.
*/
RTLDRMOD hKernel32;
int rc = RTLdrLoad("Kernel32.dll", &hKernel32);
if (RT_SUCCESS(rc))
{
PFNCREATETOOLHELP32SNAPSHOT pfnCreateToolhelp32Snapshot;
rc = RTLdrGetSymbol(hKernel32, "CreateToolhelp32Snapshot", (void**)&pfnCreateToolhelp32Snapshot);
if (RT_SUCCESS(rc))
{
PFNPROCESS32FIRST pfnProcess32First;
rc = RTLdrGetSymbol(hKernel32, "Process32First", (void**)&pfnProcess32First);
if (RT_SUCCESS(rc))
{
PFNPROCESS32NEXT pfnProcess32Next;
rc = RTLdrGetSymbol(hKernel32, "Process32Next", (void**)&pfnProcess32Next);
if (RT_SUCCESS(rc))
{
HANDLE hSnap = pfnCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if (hSnap != INVALID_HANDLE_VALUE)
{
for (size_t i = 0; papszNames[i] && !fFound; i++)
{
PROCESSENTRY32 procEntry;
procEntry.dwSize = sizeof(PROCESSENTRY32);
if (pfnProcess32First(hSnap, &procEntry))
{
do
{
if ( _stricmp(procEntry.szExeFile, papszNames[i]) == 0
&& RT_SUCCESS(rtProcGetProcessHandle(procEntry.th32ProcessID, pSid, phToken)))
{
fFound = true;
break;
}
} while (pfnProcess32Next(hSnap, &procEntry));
}
else /* Process32First */
dwErr = GetLastError();
if (FAILED(dwErr))
break;
}
CloseHandle(hSnap);
}
else /* hSnap == INVALID_HANDLE_VALUE */
dwErr = GetLastError();
}
}
}
else /* CreateToolhelp32Snapshot / Toolhelp32 API not available. */
{
/*
* NT4 needs a copy of "PSAPI.dll" (redistributed by Microsoft and not
* part of the OS) in order to get a lookup. If we don't have this DLL
* we are not able to get a token and therefore no UI will be visible.
*/
RTLDRMOD hPSAPI;
int rc = RTLdrLoad("PSAPI.dll", &hPSAPI);
if (RT_SUCCESS(rc))
{
PFNENUMPROCESSES pfnEnumProcesses;
rc = RTLdrGetSymbol(hPSAPI, "EnumProcesses", (void**)&pfnEnumProcesses);
if (RT_SUCCESS(rc))
{
PFNGETMODULEBASENAME pfnGetModuleBaseName;
rc = RTLdrGetSymbol(hPSAPI, "GetModuleBaseName", (void**)&pfnGetModuleBaseName);
if (RT_SUCCESS(rc))
{
/** @todo Retry if pBytesReturned equals cbBytes! */
DWORD adwPIDs[4096]; /* Should be sufficient for now. */
DWORD cbBytes = 0;
if (pfnEnumProcesses(adwPIDs, sizeof(adwPIDs), &cbBytes))
{
for (size_t i = 0; papszNames[i] && !fFound; i++)
{
for (DWORD dwIdx = 0; dwIdx < cbBytes/sizeof(DWORD) && !fFound; dwIdx++)
{
HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, adwPIDs[dwIdx]);
if (hProc)
{
char *pszProcName = NULL;
DWORD dwSize = 128;
do
{
RTMemRealloc(pszProcName, dwSize);
if (pfnGetModuleBaseName(hProc, 0, pszProcName, dwSize) == dwSize)
dwSize += 128;
if (dwSize > _4K) /* Play safe. */
break;
} while (GetLastError() == ERROR_INSUFFICIENT_BUFFER);
if (pszProcName)
{
if ( _stricmp(pszProcName, papszNames[i]) == 0
&& RT_SUCCESS(rtProcGetProcessHandle(adwPIDs[dwIdx], pSid, phToken)))
{
fFound = true;
}
}
if (pszProcName)
RTStrFree(pszProcName);
CloseHandle(hProc);
}
}
}
}
else
dwErr = GetLastError();
}
}
RTLdrClose(hPSAPI);
}
}
RTLdrClose(hKernel32);
}
Assert(dwErr == NO_ERROR);
return fFound;
}
/**
* Logs on a specified user and returns its primary token.
*
* @return int
*
* @param pwszUser User name.
* @param pwszPassword Password.
* @param pwszDomain Domain (not used at the moment).
* @param phToken Pointer to store the logon token.
*/
static int rtProcUserLogon(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszDomain, HANDLE *phToken)
{
/** @todo Add domain support! */
BOOL fRc = LogonUserW(pwszUser,
/*
* Because we have to deal with http://support.microsoft.com/kb/245683
* for NULL domain names when running on NT4 here, pass an empty string if so.
* However, passing FQDNs should work!
*/
((DWORD)(LOBYTE(LOWORD(GetVersion()))) < 5) /* < Windows 2000. */
? L"" /* NT4 and older. */
: NULL, /* Windows 2000 and up. */
pwszPassword,
LOGON32_LOGON_INTERACTIVE,
LOGON32_PROVIDER_DEFAULT,
phToken);
if (!fRc)
return rtProcMapErrorCodes(GetLastError());
return VINF_SUCCESS;
}
/**
* Logs off a user, specified by the given token.
*
* @param hToken The token (=user) to log off.
*/
static void rtProcUserLogoff(HANDLE hToken)
{
CloseHandle(hToken);
}
/**
* Creates an environment block out of a handed in Unicode and RTENV block.
* The RTENV block can overwrite entries already present in the Unicode block.
*
* @return IPRT status code.
*
* @param pvBlock Unicode block (array) of environment entries; name=value
* @param hEnv Handle of an existing RTENV block to use.
* @param ppwszBlock Pointer to the final output.
*/
static int rtProcEnvironmentCreateInternal(VOID *pvBlock, RTENV hEnv, PRTUTF16 *ppwszBlock)
{
int rc = VINF_SUCCESS;
RTENV hEnvTemp;
rc = RTEnvClone(&hEnvTemp, hEnv);
if (RT_SUCCESS(rc))
{
PRTUTF16 pBlock = (PRTUTF16)pvBlock;
while ( pBlock
&& pBlock != '\0'
&& RT_SUCCESS(rc))
{
char *pszEntry;
rc = RTUtf16ToUtf8(pBlock, &pszEntry);
if (RT_SUCCESS(rc))
{
/* Don't overwrite values which we already have set to a custom value
* specified in hEnv ... */
if (!RTEnvExistEx(hEnv, pszEntry))
rc = RTEnvPutEx(hEnvTemp, pszEntry);
RTStrFree(pszEntry);
}
size_t l;
/* 32k should be the maximum the environment block can have on Windows. */
if (FAILED(StringCbLengthW((LPCWSTR)pBlock, _32K * sizeof(RTUTF16), &l)))
break;
pBlock += l / sizeof(RTUTF16);
if (pBlock[1] == '\0') /* Did we reach the double zero termination (\0\0)? */
break;
pBlock++; /* Skip zero termination of current string and advance to next string ... */
}
if (RT_SUCCESS(rc))
rc = RTEnvQueryUtf16Block(hEnvTemp, ppwszBlock);
RTEnvDestroy(hEnvTemp);
}
return rc;
}
/**
* Builds up the environment block for a specified user (identified by a token),
* whereas hEnv is an additional set of environment variables which overwrite existing
* values of the user profile. ppwszBlock needs to be destroyed after usage
* calling rtProcEnvironmentDestroy().
*
* @return IPRT status code.
*
* @param hToken Token of the user to use.
* @param hEnv Own environment block to extend/overwrite the profile's data with.
* @param ppwszBlock Pointer to a pointer of the final UTF16 environment block.
*/
static int rtProcEnvironmentCreateFromToken(HANDLE hToken, RTENV hEnv, PRTUTF16 *ppwszBlock)
{
RTLDRMOD hUserenv;
int rc = RTLdrLoad("Userenv.dll", &hUserenv);
if (RT_SUCCESS(rc))
{
PFNCREATEENVIRONMENTBLOCK pfnCreateEnvironmentBlock;
rc = RTLdrGetSymbol(hUserenv, "CreateEnvironmentBlock", (void**)&pfnCreateEnvironmentBlock);
if (RT_SUCCESS(rc))
{
PFNPFNDESTROYENVIRONMENTBLOCK pfnDestroyEnvironmentBlock;
rc = RTLdrGetSymbol(hUserenv, "DestroyEnvironmentBlock", (void**)&pfnDestroyEnvironmentBlock);
if (RT_SUCCESS(rc))
{
LPVOID pEnvBlockProfile = NULL;
if (pfnCreateEnvironmentBlock(&pEnvBlockProfile, hToken, FALSE /* Don't inherit from parent. */))
{
rc = rtProcEnvironmentCreateInternal(pEnvBlockProfile, hEnv, ppwszBlock);
pfnDestroyEnvironmentBlock(pEnvBlockProfile);
}
else
rc = RTErrConvertFromWin32(GetLastError());
}
}
RTLdrClose(hUserenv);
}
/* If we don't have the Userenv-API for whatever reason or something with the
* native environment block failed, try to return at least our own environment block. */
if (RT_FAILURE(rc))
rc = RTEnvQueryUtf16Block(hEnv, ppwszBlock);
return rc;
}
/**
* Builds up the environment block for a specified user (identified by user name, password
* and domain), whereas hEnv is an additional set of environment variables which overwrite
* existing values of the user profile. ppwszBlock needs to be destroyed after usage
* calling rtProcEnvironmentDestroy().
*
* @return IPRT status code.
*
* @param pwszUser User name.
* @param pwszPassword Password.
* @param pwszDomain Domain.
* @param hEnv Own environment block to extend/overwrite the profile's data with.
* @param ppwszBlock Pointer to a pointer of the final UTF16 environment block.
*/
static int rtProcEnvironmentCreateFromAccount(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszDomain,
RTENV hEnv, PRTUTF16 *ppwszBlock)
{
HANDLE hToken;
int rc = rtProcUserLogon(pwszUser, pwszPassword, pwszDomain, &hToken);
if (RT_SUCCESS(rc))
{
rc = rtProcEnvironmentCreateFromToken(hToken, hEnv, ppwszBlock);
rtProcUserLogoff(hToken);
}
return rc;
}
/**
* Destroys an environment block formerly created by rtProcEnvironmentCreateInternal(),
* rtProcEnvironmentCreateFromToken() or rtProcEnvironmentCreateFromAccount().
*
* @param ppwszBlock Environment block to destroy.
*/
static void rtProcEnvironmentDestroy(PRTUTF16 ppwszBlock)
{
RTEnvFreeUtf16Block(ppwszBlock);
}
static int rtProcCreateAsUserHlp(PRTUTF16 pwszUser, PRTUTF16 pwszPassword, PRTUTF16 pwszExec, PRTUTF16 pwszCmdLine,
RTENV hEnv, DWORD dwCreationFlags,
STARTUPINFOW *pStartupInfo, PROCESS_INFORMATION *pProcInfo, uint32_t fFlags)
{
int rc = VINF_SUCCESS;
BOOL fRc = FALSE;
DWORD dwErr = NO_ERROR;
/*
* If we run as a service CreateProcessWithLogon will fail,
* so don't even try it (because of Local System context).
*/
if (!(fFlags & RTPROC_FLAGS_SERVICE))
{
RTLDRMOD hAdvAPI32;
rc = RTLdrLoad("Advapi32.dll", &hAdvAPI32);
if (RT_SUCCESS(rc))
{
/*
* This may fail on too old (NT4) platforms or if the calling process
* is running on a SYSTEM account (like a service, ERROR_ACCESS_DENIED) on newer
* platforms (however, this works on W2K!).
*/
PFNCREATEPROCESSWITHLOGON pfnCreateProcessWithLogonW;
rc = RTLdrGetSymbol(hAdvAPI32, "CreateProcessWithLogonW", (void**)&pfnCreateProcessWithLogonW);
if (RT_SUCCESS(rc))
{
PRTUTF16 pwszzBlock;
rc = rtProcEnvironmentCreateFromAccount(pwszUser, pwszPassword, NULL /* Domain */,
hEnv, &pwszzBlock);
if (RT_SUCCESS(rc))
{
fRc = pfnCreateProcessWithLogonW(pwszUser,
NULL, /* lpDomain*/
pwszPassword,
1 /*LOGON_WITH_PROFILE*/, /* dwLogonFlags */
pwszExec,
pwszCmdLine,
dwCreationFlags,
pwszzBlock,
NULL, /* pCurrentDirectory */
pStartupInfo,
pProcInfo);
if (!fRc)
rc = rtProcMapErrorCodes(GetLastError());
rtProcEnvironmentDestroy(pwszzBlock);
}
}
RTLdrClose(hAdvAPI32);
}
}
/*
* Did the API call above fail because we're running on a too old OS (NT4) or
* we're running as a Windows service?
*/
if ( RT_FAILURE(rc)
|| (fFlags & RTPROC_FLAGS_SERVICE))
{
/*
* So if we want to start a process from a service (RTPROC_FLAGS_SERVICE),
* we have to do the following:
* - Check the credentials supplied and get the user SID.
* - If valid get the correct Explorer/VBoxTray instance corresponding to that
* user. This of course is only possible if that user is logged in (over
* physical console or terminal services).
* - If we found the user's Explorer/VBoxTray app, use and modify the token to
* use it in order to allow the newly started process to access the user's
* desktop. If there's no Explorer/VBoxTray app we cannot display the started
* process (but run it without UI).
*
* The following restrictions apply:
* - A process only can show its UI when the user the process should run
* under is logged in (has a desktop).
* - We do not want to display a process of user A run on the desktop
* of user B on multi session systems.
*
* The following rights are needed in order to use LogonUserW and
* CreateProcessAsUserW, so the local policy has to be modified to:
* - SE_TCB_NAME = Act as part of the operating system
* - SE_ASSIGNPRIMARYTOKEN_NAME = Create/replace a token object
* - SE_INCREASE_QUOTA_NAME
*
* We may fail here with ERROR_PRIVILEGE_NOT_HELD.
*/
PHANDLE phToken = NULL;
HANDLE hTokenLogon = INVALID_HANDLE_VALUE;
rc = rtProcUserLogon(pwszUser, pwszPassword, NULL /* Domain */, &hTokenLogon);
if (RT_SUCCESS(rc))
{
bool fFound = false;
HANDLE hTokenUserDesktop = INVALID_HANDLE_VALUE;
if (fFlags & RTPROC_FLAGS_SERVICE)
{
DWORD cbSid = 0; /* Must be zero to query size! */
DWORD cchDomain = 0;
SID_NAME_USE sidNameUse = SidTypeUser;
fRc = LookupAccountNameW(NULL,
pwszUser,
NULL,
&cbSid,
NULL,
&cchDomain,
&sidNameUse);
if (!fRc)
dwErr = GetLastError();
if ( !fRc
&& dwErr == ERROR_INSUFFICIENT_BUFFER
&& cbSid > 0)
{
dwErr = NO_ERROR;
PSID pSid = (PSID)RTMemAlloc(cbSid * sizeof(wchar_t)); /** @todo r=bird: What's the relationship between wchar_t and PSID? */
AssertPtrReturn(pSid, VERR_NO_MEMORY); /** @todo r=bird: Leaking token handles when we're out of memory... */
PRTUTF16 pwszDomain = NULL;
if (cchDomain > 0)
{
pwszDomain = (PRTUTF16)RTMemAlloc(cchDomain * sizeof(RTUTF16));
AssertPtrReturn(pwszDomain, VERR_NO_MEMORY); /** @todo r=bird: Leaking token handles when we're out of memory... */
}
/* Note: Also supports FQDNs! */
if ( LookupAccountNameW(NULL, /* lpSystemName */
pwszUser,
pSid,
&cbSid,
pwszDomain,
&cchDomain,
&sidNameUse)
&& IsValidSid(pSid))
{
/* Array of process names we want to look for. */
static const char * const s_papszProcNames[] =
{
#ifdef VBOX /* The explorer entry is a fallback in case GA aren't installed. */
{ "VBoxTray.exe" },
#endif
{ "explorer.exe" },
NULL
};
fFound = rtProcFindProcessByName(s_papszProcNames, pSid, &hTokenUserDesktop);
}
else
dwErr = GetLastError(); /* LookupAccountNameW() failed. */
RTMemFree(pSid);
RTMemFree(pwszDomain);
}
}
else /* !RTPROC_FLAGS_SERVICE */
{
/* Nothing to do here right now. */
}
/** @todo Hmm, this function already is too big! We need to split
* it up into several small parts. */
/* If we got an error due to account lookup/loading above, don't
* continue here. */
if (dwErr == NO_ERROR)
{
/*
* If we didn't find a matching VBoxTray, just use the token we got
* above from LogonUserW(). This enables us to at least run processes with
* desktop interaction without UI.
*/
phToken = fFound ? &hTokenUserDesktop : &hTokenLogon;
RTLDRMOD hUserenv;
int rc = RTLdrLoad("Userenv.dll", &hUserenv);
if (RT_SUCCESS(rc))
{
PFNLOADUSERPROFILEW pfnLoadUserProfileW;
rc = RTLdrGetSymbol(hUserenv, "LoadUserProfileW", (void**)&pfnLoadUserProfileW);
if (RT_SUCCESS(rc))
{
PFNUNLOADUSERPROFILE pfnUnloadUserProfile;
rc = RTLdrGetSymbol(hUserenv, "UnloadUserProfile", (void**)&pfnUnloadUserProfile);
if (RT_SUCCESS(rc))
{
PROFILEINFOW profileInfo;
if (!(fFlags & RTPROC_FLAGS_NO_PROFILE))
{
RT_ZERO(profileInfo);
profileInfo.dwSize = sizeof(profileInfo);
profileInfo.lpUserName = pwszUser;
profileInfo.dwFlags = PI_NOUI; /* Prevents the display of profile error messages. */
if (!pfnLoadUserProfileW(*phToken, &profileInfo))
dwErr = GetLastError();
}
if (dwErr == NO_ERROR)
{
PRTUTF16 pwszzBlock;
rc = rtProcEnvironmentCreateFromToken(*phToken, hEnv, &pwszzBlock);
if (RT_SUCCESS(rc))
{
/*
* Useful KB articles:
* http://support.microsoft.com/kb/165194/
* http://support.microsoft.com/kb/184802/
* http://support.microsoft.com/kb/327618/
*/
fRc = CreateProcessAsUserW(*phToken,
pwszExec,
pwszCmdLine,
NULL, /* pProcessAttributes */
NULL, /* pThreadAttributes */
TRUE, /* fInheritHandles */
dwCreationFlags,
pwszzBlock,
NULL, /* pCurrentDirectory */
pStartupInfo,
pProcInfo);
if (fRc)
dwErr = NO_ERROR;
else
dwErr = GetLastError(); /* CreateProcessAsUserW() failed. */
rtProcEnvironmentDestroy(pwszzBlock);
}
if (!(fFlags & RTPROC_FLAGS_NO_PROFILE))
{
fRc = pfnUnloadUserProfile(*phToken, profileInfo.hProfile);
#ifdef RT_STRICT
if (!fRc)
{
DWORD dwErr2 = GetLastError();
AssertMsgFailed(("Unloading user profile failed with error %u (%#x) - Are all handles closed? (dwErr=%u)",
dwErr2, dwErr2, dwErr));
}
#endif
}
}
}
}
RTLdrClose(hUserenv);
} /* Userenv.dll found/loaded? */
} /* Account lookup succeeded? */
if (hTokenUserDesktop != INVALID_HANDLE_VALUE)
CloseHandle(hTokenUserDesktop);
rtProcUserLogoff(hTokenLogon);
}
}
if ( RT_SUCCESS(rc)
&& dwErr != NO_ERROR)
rc = rtProcMapErrorCodes(dwErr);
return rc;
}
RTR3DECL(int) RTProcCreateEx(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser,
const char *pszPassword, PRTPROCESS phProcess)
{
/*
* Input validation
*/
AssertPtrReturn(pszExec, VERR_INVALID_POINTER);
AssertReturn(*pszExec, VERR_INVALID_PARAMETER);
AssertReturn(!(fFlags & ~(RTPROC_FLAGS_DETACHED | RTPROC_FLAGS_HIDDEN | RTPROC_FLAGS_SERVICE | RTPROC_FLAGS_SAME_CONTRACT | RTPROC_FLAGS_NO_PROFILE | RTPROC_FLAGS_NO_WINDOW)), VERR_INVALID_PARAMETER);
AssertReturn(!(fFlags & RTPROC_FLAGS_DETACHED) || !phProcess, VERR_INVALID_PARAMETER);
AssertReturn(hEnv != NIL_RTENV, VERR_INVALID_PARAMETER);
AssertPtrReturn(papszArgs, VERR_INVALID_PARAMETER);
AssertPtrNullReturn(pszAsUser, VERR_INVALID_POINTER);
AssertReturn(!pszAsUser || *pszAsUser, VERR_INVALID_PARAMETER);
AssertReturn(!pszPassword || pszAsUser, VERR_INVALID_PARAMETER);
AssertPtrNullReturn(pszPassword, VERR_INVALID_POINTER);
/** @todo search the PATH (add flag for this). */
/*
* Initialize the globals.
*/
int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL, NULL);
AssertRCReturn(rc, rc);
/*
* Get the file descriptors for the handles we've been passed.
*
* It seems there is no point in trying to convince a child process's CRT
* that any of the standard file handles is non-TEXT. So, we don't...
*/
STARTUPINFOW StartupInfo;
RT_ZERO(StartupInfo);
StartupInfo.cb = sizeof(StartupInfo);
StartupInfo.dwFlags = STARTF_USESTDHANDLES;
#if 1 /* The CRT should keep the standard handles up to date. */
StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
#else
StartupInfo.hStdInput = _get_osfhandle(0);
StartupInfo.hStdOutput = _get_osfhandle(1);
StartupInfo.hStdError = _get_osfhandle(2);
#endif
/* If we want to have a hidden process (e.g. not visible to
* to the user) use the STARTUPINFO flags. */
if (fFlags & RTPROC_FLAGS_HIDDEN)
{
StartupInfo.dwFlags |= STARTF_USESHOWWINDOW;
StartupInfo.wShowWindow = SW_HIDE;
}
PCRTHANDLE paHandles[3] = { phStdIn, phStdOut, phStdErr };
HANDLE *aphStds[3] = { &StartupInfo.hStdInput, &StartupInfo.hStdOutput, &StartupInfo.hStdError };
DWORD afInhStds[3] = { 0xffffffff, 0xffffffff, 0xffffffff };
for (int i = 0; i < 3; i++)
{
if (paHandles[i])
{
AssertPtrReturn(paHandles[i], VERR_INVALID_POINTER);
switch (paHandles[i]->enmType)
{
case RTHANDLETYPE_FILE:
*aphStds[i] = paHandles[i]->u.hFile != NIL_RTFILE
? (HANDLE)RTFileToNative(paHandles[i]->u.hFile)
: INVALID_HANDLE_VALUE;
break;
case RTHANDLETYPE_PIPE:
*aphStds[i] = paHandles[i]->u.hPipe != NIL_RTPIPE
? (HANDLE)RTPipeToNative(paHandles[i]->u.hPipe)
: INVALID_HANDLE_VALUE;
break;
case RTHANDLETYPE_SOCKET:
*aphStds[i] = paHandles[i]->u.hSocket != NIL_RTSOCKET
? (HANDLE)RTSocketToNative(paHandles[i]->u.hSocket)
: INVALID_HANDLE_VALUE;
break;
default:
AssertMsgFailedReturn(("%d: %d\n", i, paHandles[i]->enmType), VERR_INVALID_PARAMETER);
}
/* Get the inheritability of the handle. */
if (*aphStds[i] != INVALID_HANDLE_VALUE)
{
if (!GetHandleInformation(*aphStds[i], &afInhStds[i]))
{
rc = RTErrConvertFromWin32(GetLastError());
AssertMsgFailedReturn(("%Rrc %p\n", rc, *aphStds[i]), rc);
}
}
}
}
/*
* Set the inheritability any handles we're handing the child.
*/
rc = VINF_SUCCESS;
for (int i = 0; i < 3; i++)
if ( (afInhStds[i] != 0xffffffff)
&& !(afInhStds[i] & HANDLE_FLAG_INHERIT))
{
if (!SetHandleInformation(*aphStds[i], HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
{
rc = RTErrConvertFromWin32(GetLastError());
AssertMsgFailedBreak(("%Rrc %p\n", rc, *aphStds[i]));
}
}
/*
* Create the environment block, command line and convert the executable
* name.
*/
PRTUTF16 pwszzBlock;
if (RT_SUCCESS(rc))
rc = RTEnvQueryUtf16Block(hEnv, &pwszzBlock);
if (RT_SUCCESS(rc))
{
PRTUTF16 pwszCmdLine;
rc = RTGetOptArgvToUtf16String(&pwszCmdLine, papszArgs, RTGETOPTARGV_CNV_QUOTE_MS_CRT);
if (RT_SUCCESS(rc))
{
PRTUTF16 pwszExec;
rc = RTStrToUtf16(pszExec, &pwszExec);
if (RT_SUCCESS(rc))
{
/*
* Get going...
*/
PROCESS_INFORMATION ProcInfo;
RT_ZERO(ProcInfo);
DWORD dwCreationFlags = CREATE_UNICODE_ENVIRONMENT;
if (fFlags & RTPROC_FLAGS_DETACHED)
dwCreationFlags |= DETACHED_PROCESS;
if (fFlags & RTPROC_FLAGS_NO_WINDOW)
dwCreationFlags |= CREATE_NO_WINDOW;
/*
* Only use the normal CreateProcess stuff if we have no user name
* and we are not running from a (Windows) service. Otherwise use
* the more advanced version in rtProcCreateAsUserHlp().
*/
if ( pszAsUser == NULL
&& !(fFlags & RTPROC_FLAGS_SERVICE))
{
if (CreateProcessW(pwszExec,
pwszCmdLine,
NULL, /* pProcessAttributes */
NULL, /* pThreadAttributes */
TRUE, /* fInheritHandles */
dwCreationFlags,
pwszzBlock,
NULL, /* pCurrentDirectory */
&StartupInfo,
&ProcInfo))
rc = VINF_SUCCESS;
else
rc = RTErrConvertFromWin32(GetLastError());
}
else
{
/*
* Convert the additional parameters and use a helper
* function to do the actual work.
*/
PRTUTF16 pwszUser;
rc = RTStrToUtf16(pszAsUser, &pwszUser);
if (RT_SUCCESS(rc))
{
PRTUTF16 pwszPassword;
rc = RTStrToUtf16(pszPassword ? pszPassword : "", &pwszPassword);
if (RT_SUCCESS(rc))
{
rc = rtProcCreateAsUserHlp(pwszUser, pwszPassword,
pwszExec, pwszCmdLine, hEnv, dwCreationFlags,
&StartupInfo, &ProcInfo, fFlags);
RTUtf16Free(pwszPassword);
}
RTUtf16Free(pwszUser);
}
}
if (RT_SUCCESS(rc))
{
CloseHandle(ProcInfo.hThread);
if (phProcess)
{
/*
* Add the process to the child process list so
* RTProcWait can reuse and close the process handle.
*/
rtProcWinAddPid(ProcInfo.dwProcessId, ProcInfo.hProcess);
*phProcess = ProcInfo.dwProcessId;
}
else
CloseHandle(ProcInfo.hProcess);
rc = VINF_SUCCESS;
}
RTUtf16Free(pwszExec);
}
RTUtf16Free(pwszCmdLine);
}
RTEnvFreeUtf16Block(pwszzBlock);
}
/* Undo any handle inherit changes. */
for (int i = 0; i < 3; i++)
if ( (afInhStds[i] != 0xffffffff)
&& !(afInhStds[i] & HANDLE_FLAG_INHERIT))
{
if (!SetHandleInformation(*aphStds[i], HANDLE_FLAG_INHERIT, 0))
AssertMsgFailed(("%Rrc %p\n", RTErrConvertFromWin32(GetLastError()), *aphStds[i]));
}
return rc;
}
RTR3DECL(int) RTProcWait(RTPROCESS Process, unsigned fFlags, PRTPROCSTATUS pProcStatus)
{
AssertReturn(!(fFlags & ~(RTPROCWAIT_FLAGS_BLOCK | RTPROCWAIT_FLAGS_NOBLOCK)), VERR_INVALID_PARAMETER);
int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL, NULL);
AssertRCReturn(rc, rc);
/*
* Try find the process among the ones we've spawned, otherwise, attempt
* opening the specified process.
*/
HANDLE hOpenedProc = NULL;
HANDLE hProcess = rtProcWinFindPid(Process);
if (hProcess == NULL)
{
hProcess = hOpenedProc = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE, FALSE, Process);
if (hProcess == NULL)
{
DWORD dwErr = GetLastError();
if (dwErr == ERROR_INVALID_PARAMETER)
return VERR_PROCESS_NOT_FOUND;
return RTErrConvertFromWin32(dwErr);
}
}
/*
* Wait for it to terminate.
*/
DWORD Millies = fFlags == RTPROCWAIT_FLAGS_BLOCK ? INFINITE : 0;
DWORD WaitRc = WaitForSingleObjectEx(hProcess, Millies, TRUE);
while (WaitRc == WAIT_IO_COMPLETION)
WaitRc = WaitForSingleObjectEx(hProcess, Millies, TRUE);
switch (WaitRc)
{
/*
* It has terminated.
*/
case WAIT_OBJECT_0:
{
DWORD dwExitCode;
if (GetExitCodeProcess(hProcess, &dwExitCode))
{
/** @todo the exit code can be special statuses. */
if (pProcStatus)
{
pProcStatus->enmReason = RTPROCEXITREASON_NORMAL;
pProcStatus->iStatus = (int)dwExitCode;
}
if (hOpenedProc == NULL)
rtProcWinRemovePid(Process);
rc = VINF_SUCCESS;
}
else
rc = RTErrConvertFromWin32(GetLastError());
break;
}
/*
* It hasn't terminated just yet.
*/
case WAIT_TIMEOUT:
rc = VERR_PROCESS_RUNNING;
break;
/*
* Something went wrong...
*/
case WAIT_FAILED:
rc = RTErrConvertFromWin32(GetLastError());
break;
case WAIT_ABANDONED:
AssertFailed();
rc = VERR_GENERAL_FAILURE;
break;
default:
AssertMsgFailed(("WaitRc=%RU32\n", WaitRc));
rc = VERR_GENERAL_FAILURE;
break;
}
if (hOpenedProc != NULL)
CloseHandle(hOpenedProc);
return rc;
}
RTR3DECL(int) RTProcWaitNoResume(RTPROCESS Process, unsigned fFlags, PRTPROCSTATUS pProcStatus)
{
/** @todo this isn't quite right. */
return RTProcWait(Process, fFlags, pProcStatus);
}
RTR3DECL(int) RTProcTerminate(RTPROCESS Process)
{
if (Process == NIL_RTPROCESS)
return VINF_SUCCESS;
int rc = RTOnce(&g_rtProcWinInitOnce, rtProcWinInitOnce, NULL, NULL);
AssertRCReturn(rc, rc);
/*
* Try find the process among the ones we've spawned, otherwise, attempt
* opening the specified process.
*/
HANDLE hProcess = rtProcWinFindPid(Process);
if (hProcess != NULL)
{
if (!TerminateProcess(hProcess, 127))
rc = RTErrConvertFromWin32(GetLastError());
}
else
{
hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, Process);
if (hProcess != NULL)
{
BOOL fRc = TerminateProcess(hProcess, 127);
DWORD dwErr = GetLastError();
CloseHandle(hProcess);
if (!fRc)
rc = RTErrConvertFromWin32(dwErr);
}
}
return rc;
}
RTR3DECL(uint64_t) RTProcGetAffinityMask(void)
{
DWORD_PTR dwProcessAffinityMask = 0xffffffff;
DWORD_PTR dwSystemAffinityMask;
BOOL fRc = GetProcessAffinityMask(GetCurrentProcess(), &dwProcessAffinityMask, &dwSystemAffinityMask);
Assert(fRc);
return dwProcessAffinityMask;
}