This source file includes following definitions.
- Fatal
- ErrorMessageToString
- ArgvQuote
- BuildCommandLine
- RunLinker
- Fallback
- Fallback
- SlurpFile
- SplitLinkRequested
- wmain
#include <windows.h>
#include <shlwapi.h>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>
#ifndef SPLIT_LINK_SCRIPT_PATH
#error SPLIT_LINK_SCRIPT_PATH must be defined as the path to "split_link.py".
#endif
#ifndef PYTHON_PATH
#error PYTHON_PATH must be defined to be the path to the python binary.
#endif
#define WIDEN2(x) L ## x
#define WIDEN(x) WIDEN2(x)
#define WPYTHON_PATH WIDEN(PYTHON_PATH)
#define WSPLIT_LINK_SCRIPT_PATH WIDEN(SPLIT_LINK_SCRIPT_PATH)
using namespace std;
static void Fatal(const wchar_t* msg) {
wprintf(L"split_link fatal error: %s\n", msg);
exit(1);
}
static wstring ErrorMessageToString(DWORD err) {
wchar_t* msg_buf = NULL;
DWORD rc = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
err,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPTSTR>(&msg_buf),
0,
NULL);
if (!rc)
return L"unknown error";
wstring ret(msg_buf);
LocalFree(msg_buf);
return ret;
}
static void ArgvQuote(const std::wstring& argument,
std::wstring* command_line) {
if (!argument.empty() &&
argument.find_first_of(L" \t\n\v\"") == argument.npos) {
command_line->append(argument);
} else {
command_line->push_back(L'"');
for (std::wstring::const_iterator it = argument.begin();; ++it) {
int num_backslashes = 0;
while (it != argument.end() && *it == L'\\') {
++it;
++num_backslashes;
}
if (it == argument.end()) {
command_line->append(num_backslashes * 2, L'\\');
break;
} else if (*it == L'"') {
command_line->append(num_backslashes * 2 + 1, L'\\');
command_line->push_back(*it);
} else {
command_line->append(num_backslashes, L'\\');
command_line->push_back(*it);
}
}
command_line->push_back(L'"');
}
}
static wstring BuildCommandLine(const vector<wstring>& args) {
std::wstring result;
for (size_t i = 0; i < args.size(); ++i) {
ArgvQuote(args[i], &result);
if (i < args.size() - 1) {
result += L" ";
}
}
return result;
}
static void RunLinker(const vector<wstring>& prefix, const wchar_t* msg) {
if (msg) {
wprintf(L"split_link failed (%s), trying to fallback to standard link.\n",
msg);
wprintf(L"Original command line: %s\n", GetCommandLine());
fflush(stdout);
}
STARTUPINFO startup_info = { sizeof(STARTUPINFO) };
PROCESS_INFORMATION process_info;
DWORD exit_code;
GetStartupInfo(&startup_info);
if (getenv("SPLIT_LINK_DEBUG")) {
wprintf(L" original command line '%s'\n", GetCommandLine());
fflush(stdout);
}
int num_args;
LPWSTR* args = CommandLineToArgvW(GetCommandLine(), &num_args);
if (!args)
Fatal(L"Couldn't parse command line.");
vector<wstring> argv;
argv.insert(argv.end(), prefix.begin(), prefix.end());
for (int i = 1; i < num_args; ++i)
argv.push_back(args[i]);
LocalFree(args);
wstring cmd = BuildCommandLine(argv);
if (getenv("SPLIT_LINK_DEBUG")) {
wprintf(L" running '%s'\n", cmd.c_str());
fflush(stdout);
}
if (!CreateProcess(NULL,
reinterpret_cast<LPWSTR>(const_cast<wchar_t *>(
cmd.c_str())),
NULL,
NULL,
TRUE,
0,
NULL,
NULL,
&startup_info, &process_info)) {
wstring error = ErrorMessageToString(GetLastError());
Fatal(error.c_str());
}
CloseHandle(process_info.hThread);
WaitForSingleObject(process_info.hProcess, INFINITE);
GetExitCodeProcess(process_info.hProcess, &exit_code);
CloseHandle(process_info.hProcess);
exit(exit_code);
}
static void Fallback(const wchar_t* msg) {
wchar_t original_link[1024];
DWORD type;
DWORD size = sizeof(original_link);
if (SHGetValue(HKEY_CURRENT_USER,
L"Software\\Chromium\\split_link_installed",
NULL,
&type,
original_link,
&size) != ERROR_SUCCESS || type != REG_SZ) {
Fatal(L"Couldn't retrieve linker location from "
L"HKCU\\Software\\Chromium\\split_link_installed.");
}
if (getenv("SPLIT_LINK_DEBUG")) {
wprintf(L" got original linker '%s'\n", original_link);
fflush(stdout);
}
vector<wstring> link_binary;
link_binary.push_back(original_link);
RunLinker(link_binary, msg);
}
static void Fallback() {
Fallback(NULL);
}
static unsigned char* SlurpFile(const wchar_t* path, size_t* length) {
HANDLE file = CreateFile(
path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if (file == INVALID_HANDLE_VALUE)
Fallback(L"couldn't open file");
LARGE_INTEGER file_size;
if (!GetFileSizeEx(file, &file_size))
Fallback(L"couldn't get file size");
*length = static_cast<size_t>(file_size.QuadPart);
unsigned char* buffer = static_cast<unsigned char*>(malloc(*length));
DWORD bytes_read = 0;
if (!ReadFile(file, buffer, *length, &bytes_read, NULL))
Fallback(L"couldn't read file");
return buffer;
}
static bool SplitLinkRequested(const wchar_t* rsp_path) {
size_t length;
unsigned char* data = SlurpFile(rsp_path, &length);
bool flag_found = false;
if (data[0] == 0xff && data[1] == 0xfe) {
wstring wide(reinterpret_cast<wchar_t*>(&data[2]),
length / sizeof(wchar_t) - 1);
flag_found = wide.find(L"/splitlink") != wide.npos;
} else {
string narrow(reinterpret_cast<char*>(data), length);
flag_found = narrow.find("/splitlink") != narrow.npos;
}
free(data);
return flag_found;
}
int wmain(int argc, wchar_t** argv) {
int rsp_file_index = -1;
if (argc < 2)
Fallback();
for (int i = 1; i < argc; ++i) {
if (argv[i][0] == L'@') {
rsp_file_index = i;
break;
}
}
if (rsp_file_index == -1)
Fallback(L"couldn't find a response file in argv");
if (getenv("SPLIT_LINK_DEBUG")) {
wstring backup_copy(&argv[rsp_file_index][1]);
backup_copy += L".copy";
wchar_t buf[1024];
swprintf(buf,
sizeof(buf),
L"copy %s %s",
&argv[rsp_file_index][1],
backup_copy.c_str());
if (_wsystem(buf) == 0)
wprintf(L"Saved original rsp as %s\n", backup_copy.c_str());
else
wprintf(L"'%s' failed.", buf);
}
if (SplitLinkRequested(&argv[rsp_file_index][1])) {
vector<wstring> link_binary;
link_binary.push_back(WPYTHON_PATH);
link_binary.push_back(WSPLIT_LINK_SCRIPT_PATH);
RunLinker(link_binary, NULL);
}
Fallback();
}