steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/misc/mptWine.cpp

751 lines
20 KiB
C++
Raw Blame History

/*
* mptWine.cpp
* -----------
* Purpose: Wine stuff.
* Notes : (currently none)
* Authors: OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "mptWine.h"
#include "mptOS.h"
#include "../common/mptFileIO.h"
#include <deque>
#include <map>
#if MPT_OS_WINDOWS
#include <windows.h>
#endif
OPENMPT_NAMESPACE_BEGIN
#if MPT_OS_WINDOWS
namespace mpt
{
namespace Wine
{
Context::Context(mpt::OS::Wine::VersionContext versionContext)
: m_VersionContext(versionContext)
, wine_get_dos_file_name(nullptr)
, wine_get_unix_file_name(nullptr)
{
if(!mpt::OS::Windows::IsWine())
{
throw mpt::Wine::Exception("Wine not detected.");
}
if(!m_VersionContext.Version().IsValid())
{
throw mpt::Wine::Exception("Unknown Wine version detected.");
}
m_Kernel32 = std::make_shared<std::optional<mpt::library>>(mpt::library::load({ mpt::library::path_search::system, mpt::library::path_prefix::none, MPT_PATH("kernel32.dll"), mpt::library::path_suffix::none }));
if(!m_Kernel32->has_value())
{
throw mpt::Wine::Exception("Could not load Wine kernel32.dll.");
}
if(!(*m_Kernel32)->bind(wine_get_unix_file_name, "wine_get_unix_file_name"))
{
throw mpt::Wine::Exception("Could not bind Wine kernel32.dll:wine_get_unix_file_name.");
}
if(!(*m_Kernel32)->bind(wine_get_dos_file_name, "wine_get_dos_file_name"))
{
throw mpt::Wine::Exception("Could not bind Wine kernel32.dll:wine_get_dos_file_name.");
}
{
std::string out;
std::string err;
try
{
if(ExecutePosixShellCommand("uname -m", out, err) != 0)
{
throw mpt::Wine::Exception("Wine 'uname -m' failed.");
}
if(!err.empty())
{
throw mpt::Wine::Exception("Wine 'uname -m' failed.");
}
out = mpt::trim(out, std::string("\r\n"));
m_Uname_m = out;
} catch(const std::exception &)
{
m_Uname_m = std::string();
}
}
try
{
m_HOME = GetPosixEnvVar("HOME");
} catch(const std::exception &)
{
m_HOME = std::string();
}
try
{
m_XDG_DATA_HOME = GetPosixEnvVar("XDG_DATA_HOME");
if(m_XDG_DATA_HOME.empty())
{
m_XDG_DATA_HOME = m_HOME + "/.local/share";
}
} catch(const std::exception &)
{
m_XDG_DATA_HOME = std::string();
}
try
{
m_XDG_CACHE_HOME = GetPosixEnvVar("XDG_CACHE_HOME");
if(m_XDG_CACHE_HOME.empty())
{
m_XDG_CACHE_HOME = m_HOME + "/.cache";
}
} catch(const std::exception &)
{
m_XDG_CACHE_HOME = std::string();
}
try
{
m_XDG_CONFIG_HOME = GetPosixEnvVar("XDG_CONFIG_HOME");
if(m_XDG_CONFIG_HOME.empty())
{
m_XDG_CONFIG_HOME = m_HOME + "/.config";
}
} catch(const std::exception &)
{
m_XDG_CONFIG_HOME = std::string();
}
}
std::string Context::PathToPosix(mpt::PathString windowsPath)
{
std::string result;
if(windowsPath.empty())
{
return result;
}
if(windowsPath.Length() >= 32000)
{
throw mpt::Wine::Exception("Path too long.");
}
LPSTR tmp = nullptr;
tmp = wine_get_unix_file_name(windowsPath.ToWide().c_str());
if(!tmp)
{
throw mpt::Wine::Exception("Wine kernel32.dll:wine_get_unix_file_name failed.");
}
result = tmp;
HeapFree(GetProcessHeap(), 0, tmp);
tmp = nullptr;
return result;
}
mpt::PathString Context::PathToWindows(std::string hostPath)
{
mpt::PathString result;
if(hostPath.empty())
{
return result;
}
if(hostPath.length() >= 32000)
{
throw mpt::Wine::Exception("Path too long.");
}
LPWSTR tmp = nullptr;
tmp = wine_get_dos_file_name(hostPath.c_str());
if(!tmp)
{
throw mpt::Wine::Exception("Wine kernel32.dll:wine_get_dos_file_name failed.");
}
result = mpt::PathString::FromWide(tmp);
HeapFree(GetProcessHeap(), 0, tmp);
tmp = nullptr;
return result;
}
std::string Context::PathToPosixCanonical(mpt::PathString windowsPath)
{
std::string result;
std::string hostPath = PathToPosix(windowsPath);
if(hostPath.empty())
{
return result;
}
std::string output;
std::string error;
int exitcode = ExecutePosixShellCommand(std::string() + "readlink -f " + EscapePosixShell(hostPath), output, error);
if(!error.empty())
{
throw mpt::Wine::Exception("Wine readlink failed: " + error);
}
if(exitcode != 0 && exitcode != 1)
{
throw mpt::Wine::Exception("Wine readlink failed.");
}
std::string trimmedOutput = mpt::trim(output, std::string("\r\n"));
result = trimmedOutput;
return result;
}
static void ExecutePosixCommandProgressDefault(void * /*userdata*/ )
{
::Sleep(10);
return;
}
static ExecuteProgressResult ExecutePosixShellScriptProgressDefault(void * /*userdata*/ )
{
::Sleep(10);
return ExecuteProgressContinueWaiting;
}
std::string Context::EscapePosixShell(std::string line)
{
const char escape_chars [] = { '|', '&', ';', '<', '>', '(', ')', '$', '`', '"', '\'', ' ', '\t' };
const char maybe_escape_chars [] = { '*', '?', '[', '#', '~', '=', '%' };
line = mpt::replace(line, std::string("\\"), std::string("\\\\"));
for(char c : escape_chars)
{
line = mpt::replace(line, std::string(1, c), std::string("\\") + std::string(1, c));
}
for(char c : maybe_escape_chars)
{
line = mpt::replace(line, std::string(1, c), std::string("\\") + std::string(1, c));
}
return line;
}
ExecResult Context::ExecutePosixShellScript(std::string script, FlagSet<ExecFlags> flags, std::map<std::string, std::vector<char> > filetree, std::string title, ExecutePosixCommandProgress progress, ExecutePosixShellScriptProgress progressCancel, void *userdata)
{
// Relevant documentation:
// https://stackoverflow.com/questions/6004070/execute-shell-commands-from-program-running-in-wine
// https://www.winehq.org/pipermail/wine-bugs/2014-January/374918.html
// https://bugs.winehq.org/show_bug.cgi?id=34730
if(!progress) progress = &ExecutePosixCommandProgressDefault;
if(!progressCancel) progressCancel = &ExecutePosixShellScriptProgressDefault;
if(flags[ExecFlagInteractive]) flags.reset(ExecFlagSilent);
if(flags[ExecFlagSplitOutput]) flags.set(ExecFlagSilent);
std::vector<mpt::PathString> tempfiles;
progress(userdata);
mpt::TempDirGuard dirWindowsTemp(mpt::CreateTempFileName());
if(dirWindowsTemp.GetDirname().empty())
{
throw mpt::Wine::Exception("Creating temporary directoy failed.");
}
const std::string dirPosix = PathToPosix(dirWindowsTemp.GetDirname());
if(dirPosix.empty())
{
throw mpt::Wine::Exception("mpt::Wine::ConvertWindowsPathToHost returned empty path.");
}
const std::string dirPosixEscape = EscapePosixShell(dirPosix);
const mpt::PathString dirWindows = dirWindowsTemp.GetDirname();
progress(userdata);
// write the script to disk
mpt::PathString scriptFilenameWindows = dirWindows + P_("script.sh");
{
mpt::ofstream tempfile(scriptFilenameWindows, std::ios::binary);
tempfile << script;
tempfile.flush();
if(!tempfile)
{
throw mpt::Wine::Exception("Error writing script.sh.");
}
}
const std::string scriptFilenamePosix = PathToPosix(scriptFilenameWindows);
if(scriptFilenamePosix.empty())
{
throw mpt::Wine::Exception("Error converting script.sh path.");
}
const std::string scriptFilenamePosixEscape = EscapePosixShell(scriptFilenamePosix);
progress(userdata);
// create a wrapper that will call the script and gather result.
mpt::PathString wrapperstarterFilenameWindows = dirWindows + P_("wrapperstarter.sh");
{
mpt::ofstream tempfile(wrapperstarterFilenameWindows, std::ios::binary);
std::string wrapperstarterscript;
wrapperstarterscript += std::string() + "#!/usr/bin/env sh" "\n";
wrapperstarterscript += std::string() + "exec /usr/bin/env sh " + dirPosixEscape + "wrapper.sh" "\n";
tempfile << wrapperstarterscript;
tempfile.flush();
if(!tempfile)
{
throw mpt::Wine::Exception("Error writing wrapper.sh.");
}
}
mpt::PathString wrapperFilenameWindows = dirWindows + P_("wrapper.sh");
std::string cleanupscript;
{
mpt::ofstream tempfile(wrapperFilenameWindows, std::ios::binary);
std::string wrapperscript;
if(!flags[ExecFlagSilent])
{
wrapperscript += "printf \"\\033]0;" + title + "\\a\"" "\n";
}
wrapperscript += "chmod u+x " + scriptFilenamePosixEscape + "\n";
wrapperscript += "cd " + dirPosixEscape + "filetree" "\n";
if(flags[ExecFlagInteractive])
{ // no stdout/stderr capturing for interactive scripts
wrapperscript += scriptFilenamePosixEscape + "\n";
wrapperscript += "MPT_RESULT=$?" "\n";
wrapperscript += "echo ${MPT_RESULT} > " + dirPosixEscape + "exit" "\n";
} else if(flags[ExecFlagSplitOutput])
{
wrapperscript += "(" + scriptFilenamePosixEscape + "; echo $? >&4) 4>" + dirPosixEscape + "exit 1>" + dirPosixEscape + "out 2>" + dirPosixEscape + "err" "\n";
} else
{
wrapperscript += "(" + scriptFilenamePosixEscape + "; echo $? >&4) 2>&1 4>" + dirPosixEscape + "exit | tee " + dirPosixEscape + "out" "\n";
}
wrapperscript += "echo done > " + dirPosixEscape + "done" "\n";
cleanupscript += "rm " + dirPosixEscape + "done" "\n";
cleanupscript += "rm " + dirPosixEscape + "exit" "\n";
if(flags[ExecFlagInteractive])
{
// nothing
} else if(flags[ExecFlagSplitOutput])
{
cleanupscript += "rm " + dirPosixEscape + "out" "\n";
cleanupscript += "rm " + dirPosixEscape + "err" "\n";
} else
{
cleanupscript += "rm " + dirPosixEscape + "out" "\n";
}
cleanupscript += "rm -r " + dirPosixEscape + "filetree" "\n";
cleanupscript += "rm " + dirPosixEscape + "script.sh" "\n";
cleanupscript += "rm " + dirPosixEscape + "wrapper.sh" "\n";
cleanupscript += "rm " + dirPosixEscape + "wrapperstarter.sh" "\n";
cleanupscript += "rm " + dirPosixEscape + "terminal.sh" "\n";
if(flags[ExecFlagAsync])
{
wrapperscript += cleanupscript;
cleanupscript.clear();
}
tempfile << wrapperscript;
tempfile.flush();
if(!tempfile)
{
throw mpt::Wine::Exception("Error writing wrapper.sh.");
}
}
progress(userdata);
::CreateDirectory((dirWindows + P_("filetree")).AsNative().c_str(), nullptr);
for(const auto &file : filetree)
{
std::vector<mpt::ustring> path = mpt::String::Split<mpt::ustring>(mpt::ToUnicode(mpt::Charset::UTF8, file.first), U_("/"));
mpt::PathString combinedPath = dirWindows + P_("filetree") + P_("\\");
if(path.size() > 1)
{
for(std::size_t singlepath = 0; singlepath < path.size() - 1; ++singlepath)
{
if(path[singlepath].empty())
{
continue;
}
combinedPath += mpt::PathString::FromUnicode(path[singlepath]);
if(!combinedPath.IsDirectory())
{
if(::CreateDirectory(combinedPath.AsNative().c_str(), nullptr) == 0)
{
throw mpt::Wine::Exception("Error writing filetree.");
}
}
combinedPath += P_("\\");
}
}
try
{
mpt::LazyFileRef out(dirWindows + P_("filetree") + P_("\\") + mpt::PathString::FromUTF8(mpt::replace(file.first, std::string("/"), std::string("\\"))));
out = file.second;
} catch(std::exception &)
{
throw mpt::Wine::Exception("Error writing filetree.");
}
}
progress(userdata);
// create a wrapper that will find a suitable terminal and run the wrapper script in the terminal window.
mpt::PathString terminalWrapperFilenameWindows = dirWindows + P_("terminal.sh");
{
mpt::ofstream tempfile(terminalWrapperFilenameWindows, std::ios::binary);
// NOTE:
// Modern terminals detach themselves from the invoking shell if another instance is already present.
// This means we cannot rely on terminal invocation being syncronous.
static constexpr const char * terminals[] =
{
"x-terminal-emulator",
"konsole",
"mate-terminal",
"xfce4-terminal",
"gnome-terminal",
"uxterm",
"xterm",
"rxvt",
};
std::string terminalscript = "\n";
for(const std::string terminal : terminals)
{
// mate-terminal on Debian 8 cannot execute commands with arguments,
// thus we use a separate script that requires no arguments to execute.
terminalscript += "if command -v " + terminal + " 2>/dev/null 1>/dev/null ; then" "\n";
terminalscript += " chmod u+x " + dirPosixEscape + "wrapperstarter.sh" "\n";
terminalscript += " exec `command -v " + terminal + "` -e \"" + dirPosixEscape + "wrapperstarter.sh\"" "\n";
terminalscript += "fi" "\n";
}
tempfile << terminalscript;
tempfile.flush();
if(!tempfile)
{
return ExecResult::Error();
}
}
progress(userdata);
// build unix command line
std::string unixcommand;
bool createProcessSuccess = false;
if(!createProcessSuccess)
{
if(flags[ExecFlagSilent])
{
unixcommand = "/usr/bin/env sh \"" + dirPosixEscape + "wrapper.sh\"";
} else
{
unixcommand = "/usr/bin/env sh \"" + dirPosixEscape + "terminal.sh\"";
}
progress(userdata);
std::wstring unixcommandW = mpt::ToWide(mpt::Charset::UTF8, unixcommand);
std::wstring titleW = mpt::ToWide(mpt::Charset::UTF8, title);
STARTUPINFOW startupInfo = {};
startupInfo.lpTitle = titleW.data();
startupInfo.cb = sizeof(startupInfo);
PROCESS_INFORMATION processInformation = {};
progress(userdata);
BOOL success = FALSE;
if(flags[ExecFlagSilent])
{
success = CreateProcessW(NULL, unixcommandW.data(), NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &startupInfo, &processInformation);
} else
{
success = CreateProcessW(NULL, unixcommandW.data(), NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &startupInfo, &processInformation);
}
progress(userdata);
createProcessSuccess = (success != FALSE);
progress(userdata);
if(success)
{
if(!flags[ExecFlagAsync])
{
// note: execution is not syncronous with all Wine versions,
// we additionally explicitly wait for "done" later
while(WaitForSingleObject(processInformation.hProcess, 0) == WAIT_TIMEOUT)
{ // wait
if(progressCancel(userdata) != ExecuteProgressContinueWaiting)
{
CloseHandle(processInformation.hThread);
CloseHandle(processInformation.hProcess);
throw mpt::Wine::Exception("Canceled.");
}
}
}
progress(userdata);
CloseHandle(processInformation.hThread);
CloseHandle(processInformation.hProcess);
}
}
progress(userdata);
// Work around Wine being unable to execute PIE binaries on Debian 9.
// Luckily, /bin/bash is still non-PIE on Debian 9.
if(!createProcessSuccess)
{
if(flags[ExecFlagSilent])
{
unixcommand = "/bin/bash \"" + dirPosixEscape + "wrapper.sh\"";
} else
{
unixcommand = "/bin/bash \"" + dirPosixEscape + "terminal.sh\"";
}
progress(userdata);
std::wstring unixcommandW = mpt::ToWide(mpt::Charset::UTF8, unixcommand);
std::wstring titleW = mpt::ToWide(mpt::Charset::UTF8, title);
STARTUPINFOW startupInfo = {};
startupInfo.lpTitle = titleW.data();
startupInfo.cb = sizeof(startupInfo);
PROCESS_INFORMATION processInformation = {};
progress(userdata);
BOOL success = FALSE;
if(flags[ExecFlagSilent])
{
success = CreateProcessW(NULL, unixcommandW.data(), NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &startupInfo, &processInformation);
} else
{
success = CreateProcessW(NULL, unixcommandW.data(), NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &startupInfo, &processInformation);
}
progress(userdata);
createProcessSuccess = (success != FALSE);
progress(userdata);
if(success)
{
if(!flags[ExecFlagAsync])
{
// note: execution is not syncronous with all Wine versions,
// we additionally explicitly wait for "done" later
while(WaitForSingleObject(processInformation.hProcess, 0) == WAIT_TIMEOUT)
{ // wait
if(progressCancel(userdata) != ExecuteProgressContinueWaiting)
{
CloseHandle(processInformation.hThread);
CloseHandle(processInformation.hProcess);
throw mpt::Wine::Exception("Canceled.");
}
}
}
progress(userdata);
CloseHandle(processInformation.hThread);
CloseHandle(processInformation.hProcess);
}
}
progress(userdata);
if(!createProcessSuccess)
{
throw mpt::Wine::Exception("CreateProcess failed.");
}
progress(userdata);
if(flags[ExecFlagAsync])
{
ExecResult result;
result.exitcode = 0;
return result;
}
while(!(dirWindows + P_("done")).IsFile())
{ // wait
if(progressCancel(userdata) != ExecuteProgressContinueWaiting)
{
throw mpt::Wine::Exception("Canceled.");
}
}
progress(userdata);
int exitCode = 0;
{
mpt::ifstream exitFile(dirWindows + P_("exit"), std::ios::binary);
if(!exitFile)
{
throw mpt::Wine::Exception("Script .exit file not found.");
}
std::string exitString;
exitFile >> exitString;
if(exitString.empty())
{
throw mpt::Wine::Exception("Script .exit file empty.");
}
exitCode = ConvertStrTo<int>(exitString);
}
progress(userdata);
std::string outputString;
if(!flags[ExecFlagInteractive])
{
mpt::ifstream outputFile(dirWindows + P_("out"), std::ios::binary);
if(outputFile)
{
outputFile.seekg(0, std::ios::end);
std::streampos outputFileSize = outputFile.tellg();
outputFile.seekg(0, std::ios::beg);
std::vector<char> outputFileBuf(mpt::saturate_cast<std::size_t>(static_cast<std::streamoff>(outputFileSize)));
outputFile.read(&outputFileBuf[0], outputFileBuf.size());
outputString = mpt::buffer_cast<std::string>(outputFileBuf);
}
}
progress(userdata);
std::string errorString;
if(flags[ExecFlagSplitOutput])
{
mpt::ifstream errorFile(dirWindows + P_("err"), std::ios::binary);
if(errorFile)
{
errorFile.seekg(0, std::ios::end);
std::streampos errorFileSize = errorFile.tellg();
errorFile.seekg(0, std::ios::beg);
std::vector<char> errorFileBuf(mpt::saturate_cast<std::size_t>(static_cast<std::streamoff>(errorFileSize)));
errorFile.read(&errorFileBuf[0], errorFileBuf.size());
errorString = mpt::buffer_cast<std::string>(errorFileBuf);
}
}
progress(userdata);
ExecResult result;
result.exitcode = exitCode;
result.output = outputString;
result.error = errorString;
std::deque<mpt::PathString> paths;
paths.push_back(dirWindows + P_("filetree"));
mpt::PathString basePath = (dirWindows + P_("filetree")).EnsureTrailingSlash();
while(!paths.empty())
{
mpt::PathString path = paths.front();
paths.pop_front();
path.EnsureTrailingSlash();
HANDLE hFind = NULL;
WIN32_FIND_DATA wfd = {};
hFind = FindFirstFile((path + P_("*.*")).AsNative().c_str(), &wfd);
if(hFind != NULL && hFind != INVALID_HANDLE_VALUE)
{
do
{
mpt::PathString filename = mpt::PathString::FromNative(wfd.cFileName);
if(filename != P_(".") && filename != P_(".."))
{
filename = path + filename;
filetree[filename.ToUTF8()] = std::vector<char>();
if(filename.IsDirectory())
{
paths.push_back(filename);
} else if(filename.IsFile())
{
try
{
mpt::LazyFileRef f(filename);
std::vector<char> buf = f;
mpt::PathString treeFilename = mpt::PathString::FromNative(filename.AsNative().substr(basePath.AsNative().length()));
result.filetree[treeFilename.ToUTF8()] = buf;
} catch (std::exception &)
{
// nothing?!
}
}
}
} while(FindNextFile(hFind, &wfd));
FindClose(hFind);
}
}
mpt::DeleteWholeDirectoryTree(dirWindows);
return result;
}
int Context::ExecutePosixShellCommand(std::string command, std::string & output, std::string & error)
{
std::string script;
script += "#!/usr/bin/env sh" "\n";
script += "exec " + command + "\n";
mpt::Wine::ExecResult execResult = ExecutePosixShellScript
( script
, mpt::Wine::ExecFlagSilent | mpt::Wine::ExecFlagSplitOutput, std::map<std::string, std::vector<char> >()
, std::string()
, nullptr
, nullptr
, nullptr
);
output = execResult.output;
error = execResult.error;
return execResult.exitcode;
}
std::string Context::GetPosixEnvVar(std::string var, std::string def)
{
// We cannot use std::getenv here because Wine overrides SOME env vars,
// in particular, HOME is unset in the Wine environment.
// Instead, we just spawn a shell that will catch up a sane environment on
// its own.
std::string output;
std::string error;
int exitcode = ExecutePosixShellCommand(std::string() + "echo $" + var, output, error);
if(!error.empty())
{
throw mpt::Wine::Exception("Wine echo $var failed: " + error);
}
if(exitcode != 0)
{
throw mpt::Wine::Exception("Wine echo $var failed.");
}
std::string result = mpt::trim_right(output, std::string("\r\n"));
if(result.empty())
{
result = def;
}
return result;
}
} // namespace Wine
} // namespace mpt
#else // !MPT_OS_WINDOWS
MPT_MSVC_WORKAROUND_LNK4221(mptWine)
#endif // MPT_OS_WINDOWS
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink