537 lines
14 KiB
C++
537 lines
14 KiB
C++
#include "ProcessUtils.h"
|
|
|
|
#include "FileUtils.h"
|
|
#include "Platform.h"
|
|
#include "StringUtils.h"
|
|
#include "Log.h"
|
|
|
|
#include <string.h>
|
|
#include <vector>
|
|
#include <iostream>
|
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
#include <windows.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <sys/wait.h>
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
#ifdef PLATFORM_MAC
|
|
#include <Security/Security.h>
|
|
#include <mach-o/dyld.h>
|
|
#endif
|
|
|
|
PLATFORM_PID ProcessUtils::currentProcessId()
|
|
{
|
|
#ifdef PLATFORM_UNIX
|
|
return getpid();
|
|
#else
|
|
return GetCurrentProcessId();
|
|
#endif
|
|
}
|
|
|
|
int ProcessUtils::runSync(const std::string& executable,
|
|
const std::list<std::string>& args)
|
|
{
|
|
#ifdef PLATFORM_UNIX
|
|
return runSyncUnix(executable,args);
|
|
#else
|
|
return runWindows(executable,args,RunSync);
|
|
#endif
|
|
}
|
|
|
|
#ifdef PLATFORM_UNIX
|
|
int ProcessUtils::runSyncUnix(const std::string& executable,
|
|
const std::list<std::string>& args)
|
|
{
|
|
PLATFORM_PID pid = runAsyncUnix(executable,args);
|
|
int status = 0;
|
|
if (waitpid(pid,&status,0) != -1)
|
|
{
|
|
if (WIFEXITED(status))
|
|
{
|
|
return static_cast<char>(WEXITSTATUS(status));
|
|
}
|
|
else
|
|
{
|
|
LOG(Warn,"Child exited abnormally");
|
|
return -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG(Warn,"Failed to get exit status of child " + intToStr(pid));
|
|
return WaitFailed;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void ProcessUtils::runAsync(const std::string& executable,
|
|
const std::list<std::string>& args)
|
|
{
|
|
#ifdef PLATFORM_WINDOWS
|
|
runWindows(executable,args,RunAsync);
|
|
#elif defined(PLATFORM_UNIX)
|
|
runAsyncUnix(executable,args);
|
|
#endif
|
|
}
|
|
|
|
int ProcessUtils::runElevated(const std::string& executable,
|
|
const std::list<std::string>& args,
|
|
const std::string& task)
|
|
{
|
|
#ifdef PLATFORM_WINDOWS
|
|
(void)task;
|
|
return runElevatedWindows(executable,args);
|
|
#elif defined(PLATFORM_MAC)
|
|
(void)task;
|
|
return runElevatedMac(executable,args);
|
|
#elif defined(PLATFORM_LINUX)
|
|
return runElevatedLinux(executable,args,task);
|
|
#endif
|
|
}
|
|
|
|
bool ProcessUtils::waitForProcess(PLATFORM_PID pid)
|
|
{
|
|
#ifdef PLATFORM_UNIX
|
|
pid_t result = ::waitpid(pid, 0, 0);
|
|
if (result < 0)
|
|
{
|
|
LOG(Error,"waitpid() failed with error: " + std::string(strerror(errno)));
|
|
}
|
|
return result > 0;
|
|
#elif defined(PLATFORM_WINDOWS)
|
|
HANDLE hProc;
|
|
|
|
if (!(hProc = OpenProcess(SYNCHRONIZE, FALSE, pid)))
|
|
{
|
|
LOG(Error,"Unable to get process handle for pid " + intToStr(pid) + " last error " + intToStr(GetLastError()));
|
|
return false;
|
|
}
|
|
|
|
DWORD dwRet = WaitForSingleObject(hProc, INFINITE);
|
|
CloseHandle(hProc);
|
|
|
|
if (dwRet == WAIT_FAILED)
|
|
{
|
|
LOG(Error,"WaitForSingleObject failed with error " + intToStr(GetLastError()));
|
|
}
|
|
|
|
return (dwRet == WAIT_OBJECT_0);
|
|
#endif
|
|
}
|
|
|
|
#ifdef PLATFORM_LINUX
|
|
int ProcessUtils::runElevatedLinux(const std::string& executable,
|
|
const std::list<std::string>& args,
|
|
const std::string& _task)
|
|
{
|
|
std::string task(_task);
|
|
if (task.empty())
|
|
{
|
|
task = FileUtils::fileName(executable.c_str());
|
|
}
|
|
|
|
// try available graphical sudo instances until we find one that works.
|
|
// The different sudo front-ends have different behaviors with respect to error codes:
|
|
//
|
|
// - 'kdesudo': return 1 if the user enters the wrong password 3 times or if
|
|
// they cancel elevation
|
|
//
|
|
// - recent 'gksudo' versions: return 1 if the user enters the wrong password
|
|
// : return -1 if the user cancels elevation
|
|
//
|
|
// - older 'gksudo' versions : return 0 if the user cancels elevation
|
|
|
|
std::vector<std::string> sudos;
|
|
|
|
if (getenv("KDE_SESSION_VERSION"))
|
|
{
|
|
sudos.push_back("kdesudo");
|
|
}
|
|
sudos.push_back("gksudo");
|
|
|
|
for (unsigned int i=0; i < sudos.size(); i++)
|
|
{
|
|
const std::string& sudoBinary = sudos.at(i);
|
|
|
|
std::list<std::string> sudoArgs;
|
|
sudoArgs.push_back("-u");
|
|
sudoArgs.push_back("root");
|
|
|
|
if (sudoBinary == "kdesudo")
|
|
{
|
|
sudoArgs.push_back("-d");
|
|
sudoArgs.push_back("--comment");
|
|
std::string sudoMessage = task + " needs administrative privileges. Please enter your password.";
|
|
sudoArgs.push_back(sudoMessage);
|
|
}
|
|
else if (sudoBinary == "gksudo")
|
|
{
|
|
sudoArgs.push_back("--description");
|
|
sudoArgs.push_back(task);
|
|
}
|
|
else
|
|
{
|
|
sudoArgs.push_back(task);
|
|
}
|
|
|
|
sudoArgs.push_back("--");
|
|
sudoArgs.push_back(executable);
|
|
std::copy(args.begin(),args.end(),std::back_inserter(sudoArgs));
|
|
|
|
int result = ProcessUtils::runSync(sudoBinary,sudoArgs);
|
|
|
|
LOG(Info,"Tried to use sudo " + sudoBinary + " with response " + intToStr(result));
|
|
|
|
if (result != RunFailed)
|
|
{
|
|
return result;
|
|
break;
|
|
}
|
|
}
|
|
return RunElevatedFailed;
|
|
}
|
|
#endif
|
|
|
|
#ifdef PLATFORM_MAC
|
|
int ProcessUtils::runElevatedMac(const std::string& executable,
|
|
const std::list<std::string>& args)
|
|
{
|
|
// request elevation using the Security Service.
|
|
//
|
|
// This only works when the application is being run directly
|
|
// from the Mac. Attempting to run the app via a remote SSH session
|
|
// (for example) will fail with an interaction-not-allowed error
|
|
|
|
OSStatus status;
|
|
AuthorizationRef authorizationRef;
|
|
|
|
status = AuthorizationCreate(
|
|
NULL,
|
|
kAuthorizationEmptyEnvironment,
|
|
kAuthorizationFlagDefaults,
|
|
&authorizationRef);
|
|
|
|
AuthorizationItem right = { kAuthorizationRightExecute, 0, NULL, 0 };
|
|
AuthorizationRights rights = { 1, &right };
|
|
|
|
AuthorizationFlags flags = kAuthorizationFlagDefaults |
|
|
kAuthorizationFlagInteractionAllowed |
|
|
kAuthorizationFlagPreAuthorize |
|
|
kAuthorizationFlagExtendRights;
|
|
|
|
if (status == errAuthorizationSuccess)
|
|
{
|
|
status = AuthorizationCopyRights(authorizationRef, &rights, NULL,
|
|
flags, NULL);
|
|
|
|
if (status == errAuthorizationSuccess)
|
|
{
|
|
char** argv;
|
|
argv = (char**) malloc(sizeof(char*) * args.size() + 1);
|
|
|
|
unsigned int i = 0;
|
|
for (std::list<std::string>::const_iterator iter = args.begin(); iter != args.end(); iter++)
|
|
{
|
|
argv[i] = strdup(iter->c_str());
|
|
++i;
|
|
}
|
|
argv[i] = NULL;
|
|
|
|
FILE* pipe = NULL;
|
|
|
|
char* tool = strdup(executable.c_str());
|
|
|
|
status = AuthorizationExecuteWithPrivileges(authorizationRef, tool,
|
|
kAuthorizationFlagDefaults, argv, &pipe);
|
|
|
|
if (status == errAuthorizationSuccess)
|
|
{
|
|
// AuthorizationExecuteWithPrivileges does not provide a way to get the process ID
|
|
// of the child process.
|
|
//
|
|
// Discussions on Apple development forums suggest two approaches for working around this,
|
|
//
|
|
// - Modify the child process to sent its process ID back to the parent via
|
|
// the pipe passed to AuthorizationExecuteWithPrivileges.
|
|
//
|
|
// - Use the generic Unix wait() call.
|
|
//
|
|
// This code uses wait(), which is simpler, but suffers from the problem that wait() waits
|
|
// for any child process, not necessarily the specific process launched
|
|
// by AuthorizationExecuteWithPrivileges.
|
|
//
|
|
// Apple's documentation (see 'Authorization Services Programming Guide') suggests
|
|
// installing files in an installer as a legitimate use for
|
|
// AuthorizationExecuteWithPrivileges but in general strongly recommends
|
|
// not using this call and discusses a number of other alternatives
|
|
// for performing privileged operations,
|
|
// which we could consider in future.
|
|
|
|
int childStatus;
|
|
pid_t childPid = wait(&childStatus);
|
|
|
|
if (childStatus != 0)
|
|
{
|
|
LOG(Error,"elevated process failed with status " + intToStr(childStatus) + " pid "
|
|
+ intToStr(childPid));
|
|
}
|
|
else
|
|
{
|
|
LOG(Info,"elevated process succeded with pid " + intToStr(childPid));
|
|
}
|
|
|
|
return childStatus;
|
|
}
|
|
else
|
|
{
|
|
LOG(Error,"failed to launch elevated process " + intToStr(status));
|
|
return RunElevatedFailed;
|
|
}
|
|
|
|
// If we want to know more information about what has happened:
|
|
// http://developer.apple.com/mac/library/documentation/Security/Reference/authorization_ref/Reference/reference.html#//apple_ref/doc/uid/TP30000826-CH4g-CJBEABHG
|
|
free(tool);
|
|
for (i = 0; i < args.size(); i++)
|
|
{
|
|
free(argv[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG(Error,"failed to get rights to launch elevated process. status: " + intToStr(status));
|
|
return RunElevatedFailed;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return RunElevatedFailed;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// convert a list of arguments in a space-separated string.
|
|
// Arguments containing spaces are enclosed in quotes
|
|
std::string quoteArgs(const std::list<std::string>& arguments)
|
|
{
|
|
std::string quotedArgs;
|
|
for (std::list<std::string>::const_iterator iter = arguments.begin();
|
|
iter != arguments.end();
|
|
iter++)
|
|
{
|
|
std::string arg = *iter;
|
|
|
|
bool isQuoted = !arg.empty() &&
|
|
arg.at(0) == '"' &&
|
|
arg.at(arg.size()-1) == '"';
|
|
|
|
if (!isQuoted && arg.find(' ') != std::string::npos)
|
|
{
|
|
arg.insert(0,"\"");
|
|
arg.append("\"");
|
|
}
|
|
quotedArgs += arg;
|
|
quotedArgs += " ";
|
|
}
|
|
return quotedArgs;
|
|
}
|
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
int ProcessUtils::runElevatedWindows(const std::string& executable,
|
|
const std::list<std::string>& arguments)
|
|
{
|
|
std::string args = quoteArgs(arguments);
|
|
|
|
SHELLEXECUTEINFO executeInfo;
|
|
ZeroMemory(&executeInfo,sizeof(executeInfo));
|
|
executeInfo.cbSize = sizeof(SHELLEXECUTEINFO);
|
|
executeInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
|
|
// request UAC elevation
|
|
executeInfo.lpVerb = "runas";
|
|
executeInfo.lpFile = executable.c_str();
|
|
executeInfo.lpParameters = args.c_str();
|
|
executeInfo.nShow = SW_SHOWNORMAL;
|
|
|
|
LOG(Info,"Attempting to execute " + executable + " with administrator priviledges");
|
|
if (!ShellExecuteEx(&executeInfo))
|
|
{
|
|
LOG(Error,"Failed to start with admin priviledges using ShellExecuteEx()");
|
|
return RunElevatedFailed;
|
|
}
|
|
|
|
WaitForSingleObject(executeInfo.hProcess, INFINITE);
|
|
|
|
// this assumes the process succeeded - we need to check whether
|
|
// this is actually the case.
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#ifdef PLATFORM_UNIX
|
|
PLATFORM_PID ProcessUtils::runAsyncUnix(const std::string& executable,
|
|
const std::list<std::string>& args)
|
|
{
|
|
pid_t child = fork();
|
|
if (child == 0)
|
|
{
|
|
// in child process
|
|
char** argBuffer = new char*[args.size() + 2];
|
|
argBuffer[0] = strdup(executable.c_str());
|
|
int i = 1;
|
|
for (std::list<std::string>::const_iterator iter = args.begin(); iter != args.end(); iter++)
|
|
{
|
|
argBuffer[i] = strdup(iter->c_str());
|
|
++i;
|
|
}
|
|
argBuffer[i] = 0;
|
|
|
|
if (execvp(executable.c_str(),argBuffer) == -1)
|
|
{
|
|
LOG(Error,"error starting child: " + std::string(strerror(errno)));
|
|
exit(RunFailed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LOG(Info,"Started child process " + intToStr(child));
|
|
}
|
|
return child;
|
|
}
|
|
#endif
|
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
int ProcessUtils::runWindows(const std::string& _executable,
|
|
const std::list<std::string>& _args,
|
|
RunMode runMode)
|
|
{
|
|
// most Windows API functions allow back and forward slashes to be
|
|
// used interchangeably. However, an application started with
|
|
// CreateProcess() may fail to find Side-by-Side library dependencies
|
|
// in the same directory as the executable if forward slashes are
|
|
// used as path separators, so convert the path to use back slashes here.
|
|
//
|
|
// This may be related to LoadLibrary() requiring backslashes instead
|
|
// of forward slashes.
|
|
std::string executable = FileUtils::toWindowsPathSeparators(_executable);
|
|
|
|
std::list<std::string> args(_args);
|
|
args.push_front(executable);
|
|
std::string commandLine = quoteArgs(args);
|
|
|
|
STARTUPINFO startupInfo;
|
|
ZeroMemory(&startupInfo,sizeof(startupInfo));
|
|
startupInfo.cb = sizeof(startupInfo);
|
|
|
|
PROCESS_INFORMATION processInfo;
|
|
ZeroMemory(&processInfo,sizeof(processInfo));
|
|
|
|
char* commandLineStr = strdup(commandLine.c_str());
|
|
bool result = CreateProcess(
|
|
executable.c_str(),
|
|
commandLineStr,
|
|
0 /* process attributes */,
|
|
0 /* thread attributes */,
|
|
false /* inherit handles */,
|
|
NORMAL_PRIORITY_CLASS /* creation flags */,
|
|
0 /* environment */,
|
|
0 /* current directory */,
|
|
&startupInfo /* startup info */,
|
|
&processInfo /* process information */
|
|
);
|
|
|
|
if (!result)
|
|
{
|
|
LOG(Error,"Failed to start child process. " + executable + " Last error: " + intToStr(GetLastError()));
|
|
return RunFailed;
|
|
}
|
|
else
|
|
{
|
|
if (runMode == RunSync)
|
|
{
|
|
if (WaitForSingleObject(processInfo.hProcess,INFINITE) == WAIT_OBJECT_0)
|
|
{
|
|
DWORD status = WaitFailed;
|
|
if (GetExitCodeProcess(processInfo.hProcess,&status) != 0)
|
|
{
|
|
LOG(Error,"Failed to get exit code for process");
|
|
}
|
|
return status;
|
|
}
|
|
else
|
|
{
|
|
LOG(Error,"Failed to wait for process to finish");
|
|
return WaitFailed;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// process is being run asynchronously - return zero as if it had
|
|
// succeeded
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
std::string ProcessUtils::currentProcessPath()
|
|
{
|
|
#ifdef PLATFORM_LINUX
|
|
std::string path = FileUtils::canonicalPath("/proc/self/exe");
|
|
LOG(Info,"Current process path " + path);
|
|
return path;
|
|
#elif defined(PLATFORM_MAC)
|
|
uint32_t bufferSize = PATH_MAX;
|
|
char buffer[bufferSize];
|
|
_NSGetExecutablePath(buffer,&bufferSize);
|
|
return buffer;
|
|
#else
|
|
char fileName[MAX_PATH];
|
|
GetModuleFileName(0 /* get path of current process */,fileName,MAX_PATH);
|
|
return fileName;
|
|
#endif
|
|
}
|
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
void ProcessUtils::convertWindowsCommandLine(LPCWSTR commandLine, int& argc, char**& argv)
|
|
{
|
|
argc = 0;
|
|
LPWSTR* argvUnicode = CommandLineToArgvW(commandLine,&argc);
|
|
|
|
argv = new char*[argc];
|
|
for (int i=0; i < argc; i++)
|
|
{
|
|
const int BUFFER_SIZE = 4096;
|
|
char buffer[BUFFER_SIZE];
|
|
|
|
int length = WideCharToMultiByte(CP_ACP,
|
|
0 /* flags */,
|
|
argvUnicode[i],
|
|
-1, /* argvUnicode is null terminated */
|
|
buffer,
|
|
BUFFER_SIZE,
|
|
0,
|
|
false);
|
|
|
|
// note: if WideCharToMultiByte() fails it will return zero,
|
|
// in which case we store a zero-length argument in argv
|
|
if (length == 0)
|
|
{
|
|
argv[i] = new char[1];
|
|
argv[i][0] = '\0';
|
|
}
|
|
else
|
|
{
|
|
// if the input string to WideCharToMultiByte is null-terminated,
|
|
// the output is also null-terminated
|
|
argv[i] = new char[length];
|
|
strncpy(argv[i],buffer,length);
|
|
}
|
|
}
|
|
LocalFree(argvUnicode);
|
|
}
|
|
#endif
|
|
|