add self updater (#1352)

* add self updater

* remove updater tests after validation

src/updater/main.cpp

@@ -0,0 +1,167 @@
+#include "UpdateInstaller.h"
+
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <limits>
+#include <stdexcept>
+#include <thread>
+#include <vector>
+
+#ifdef _WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#else
+#include <cerrno>
+#include <csignal>
+#include <spawn.h>
+#include <unistd.h>
+extern char** environ;
+#endif
+
+namespace {
+namespace fs = std::filesystem;
+
+bool WaitForParent(unsigned long pid) {
+#ifdef _WIN32
+	HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid);
+	if (!process) {
+		return GetLastError() == ERROR_INVALID_PARAMETER;
+	}
+	const auto result = WaitForSingleObject(process, 120000);
+	CloseHandle(process);
+	return result == WAIT_OBJECT_0;
+#else
+	if (pid > static_cast<unsigned long>(std::numeric_limits<pid_t>::max())) {
+		return false;
+	}
+	const auto deadline = std::chrono::steady_clock::now() + std::chrono::minutes(2);
+	while (std::chrono::steady_clock::now() < deadline) {
+		if (kill(static_cast<pid_t>(pid), 0) != 0) {
+			return errno == ESRCH;
+		}
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
+	}
+	return false;
+#endif
+}
+
+bool Launch(const fs::path& launcher, const fs::path& directory) {
+#ifdef _WIN32
+	std::wstring command = L"\"" + launcher.wstring() + L"\"";
+	STARTUPINFOW startup {};
+	startup.cb = sizeof(startup);
+	PROCESS_INFORMATION process {};
+	if (!CreateProcessW(launcher.c_str(), command.data(), nullptr, nullptr, FALSE, 0, nullptr,
+	                    directory.c_str(), &startup, &process)) {
+		return false;
+	}
+	CloseHandle(process.hThread);
+	CloseHandle(process.hProcess);
+	return true;
+#else
+	if (chdir(directory.c_str()) != 0) {
+		return false;
+	}
+	setsid();
+	pid_t child;
+	char* arguments[] = {const_cast<char*>(launcher.c_str()), nullptr};
+	return posix_spawn(&child, launcher.c_str(), nullptr, nullptr, arguments, environ) == 0;
+#endif
+}
+
+void WriteResult(const fs::path& workspace, const fs::path& target,
+                 const Kyty::Updater::Result& result) try {
+	const auto    temporary = workspace / "update-result.txt";
+	std::ofstream stream(temporary, std::ios::trunc);
+	stream << (result.success ? "success\n" : "failure\n") << result.message;
+	stream.close();
+	if (!stream) {
+		throw std::runtime_error("Cannot write the update result.");
+	}
+	const auto destination = target / ".kyty-update-result";
+	// Never open the destination: rename safely replaces even an existing symlink.
+	std::error_code ignored;
+	fs::remove(destination, ignored);
+	fs::rename(temporary, destination);
+} catch (const std::exception& error) {
+	// Reporting must never prevent the original or updated launcher restarting.
+	std::cerr << "Cannot record update result: " << error.what() << '\n';
+}
+
+void CleanupWorkspace(const fs::path& source, const fs::path& target) try {
+	const auto workspace = source.parent_path();
+	if (source.filename() != "payload" ||
+	    !workspace.filename().string().starts_with(".kyty-update-") ||
+	    fs::canonical(workspace.parent_path()) != fs::canonical(target)) {
+		return;
+	}
+	// Windows cannot unlink the running helper. Remove the archive and payload
+	// separately so that only this small executable can remain after success.
+	for (const auto& entry: fs::directory_iterator(workspace)) {
+		std::error_code ignored;
+		fs::remove_all(entry.path(), ignored);
+	}
+	std::error_code ignored;
+	fs::remove(workspace, ignored);
+} catch (const std::exception& error) {
+	std::cerr << "Update installed; temporary files could not be removed: " << error.what() << '\n';
+}
+
+int Run(const std::vector<fs::path>& arguments) {
+	const bool validate = arguments.size() == 5 && arguments[1] == "--validate";
+	const bool install  = arguments.size() == 7 && arguments[1] == "--install";
+	if (!validate && !install) {
+		std::cerr
+		    << "Usage: kyty_updater --validate SOURCE TARGET LAUNCHER_REL\n"
+		       "       kyty_updater --install SOURCE TARGET LAUNCHER_REL PARENT_PID WORKDIR\n";
+		return 2;
+	}
+	const auto source   = fs::absolute(arguments[2]);
+	const auto target   = fs::absolute(arguments[3]);
+	const auto launcher = arguments[4];
+	if (validate) {
+		const auto result = Kyty::Updater::Validate(source, target, launcher);
+		if (!result.success) {
+			std::cerr << result.message << '\n';
+		}
+		return result.success ? 0 : 1;
+	}
+	const auto  pid_string = arguments[5].string();
+	std::size_t consumed   = 0;
+	const auto  pid        = std::stoul(pid_string, &consumed);
+	if (pid <= 1 || consumed != pid_string.size() || pid_string.front() == '-') {
+		throw std::runtime_error("Invalid launcher process identifier.");
+	}
+	if (!WaitForParent(pid)) {
+		WriteResult(source.parent_path(), target,
+		            {false, "Update cancelled: the launcher did not exit within two minutes."});
+		return 1;
+	}
+	auto result = Kyty::Updater::Install(source, target, launcher);
+	WriteResult(source.parent_path(), target, result);
+	if (!Launch(target / launcher, fs::absolute(arguments[6]))) {
+		result.message += "\nThe launcher could not restart. Open it manually.";
+		WriteResult(source.parent_path(), target, result);
+		std::cerr << result.message << '\n';
+		return 1;
+	}
+	if (result.success) {
+		CleanupWorkspace(source, target);
+	}
+	return result.success ? 0 : 1;
+}
+} // namespace
+
+#ifdef _WIN32
+int wmain(int argc, wchar_t* argv[]) {
+#else
+int main(int argc, char* argv[]) {
+#endif
+	try {
+		return Run(std::vector<fs::path>(argv, argv + argc));
+	} catch (const std::exception& error) {
+		std::cerr << error.what() << '\n';
+		return 1;
+	}
+}