// the first-time installer. one exe, nothing beside it: the stub rides along // as a resource and everything else comes from garage. // // asks who its for (if the developer left that on), asks garage what the // newest windows build is, downloads it, checks the sha256, puts the stub in // and has the stub unpack the zip, so theres one bit of code that knows // how a version folder is made. then a start menu shortcut, an entry in // "installed apps", and the app is started. // // who its for decides where it goes: // just me %LOCALAPPDATA%\Programs\, nothing needs admin, ever // everyone %ProgramFiles%\, and we start ourselves again elevated // // the window is a task dialog. windows lays it out and draws it, theres no // layout code in here to get wrong on somebody elses dpi. #include "garage_common.h" #include "installer_config.h" #include #include #include #include #include #include using namespace garage; enum { kExitOk = 0, kExitFailed = 1, kExitCancelled = 2 }; enum { ID_INSTALL = 1001 }; enum { RADIO_ME = 2001, RADIO_EVERYONE = 2002 }; enum Page { PAGE_CHOICE, PAGE_PROGRESS, PAGE_ERROR }; static const wchar_t* kAppName = GARAGE_APP_NAME; static const wchar_t* kPublisher = GARAGE_PUBLISHER; static const wchar_t* kUserAgent = L"garage_updates-installer/1"; static bool g_everyone = GARAGE_DEFAULT_EVERYONE != 0; static bool g_showChoice = GARAGE_SHOW_CHOICE != 0; static bool g_desktopShortcut = GARAGE_DESKTOP_SHORTCUT != 0; // started by ourselves through the uac prompt. the one that asked is still // there waiting, and its the one that starts the app afterwards static bool g_elevatedChild = false; static Page g_page = PAGE_CHOICE; static int g_exit = kExitCancelled; static HANDLE g_child = nullptr; static HICON g_icon = nullptr; static HANDLE g_worker = nullptr; static volatile LONG g_cancel = 0; static bool g_marquee = false; static std::wstring g_shown; // what the worker thread has to say to the window. the window reads it on a timer static CRITICAL_SECTION g_lock; static struct { std::wstring status; int permille = -1; // -1 is "no idea how long", the bar just slides bool done = false; bool ok = false; std::wstring error; } g_progress; static std::wstring g_logDir; // ---- small things ---- static void log_line(const std::wstring& msg) { OutputDebugStringW((L"garage_setup: " + msg + L"\n").c_str()); if (g_logDir.empty()) return; SYSTEMTIME t; GetLocalTime(&t); wchar_t stamp[48]; wsprintfW(stamp, L"%04d-%02d-%02d %02d:%02d:%02d ", t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond); std::string bytes = narrow(stamp + msg) + "\r\n"; HANDLE h = CreateFileW(lp(join(g_logDir, L"setup.log")).c_str(), FILE_APPEND_DATA, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (h == INVALID_HANDLE_VALUE) { OutputDebugStringW(L"garage_setup: and the log couldnt be opened\n"); return; } DWORD wrote = 0; WriteFile(h, bytes.data(), (DWORD)bytes.size(), &wrote, nullptr); CloseHandle(h); } static void log_fail(const std::wstring& what, DWORD err) { log_line(what + L" (win32 " + win_error(err) + L")"); } static bool cancelled() { return InterlockedCompareExchange(&g_cancel, 0, 0) != 0; } static void set_status(const std::wstring& status, int permille) { EnterCriticalSection(&g_lock); g_progress.status = status; g_progress.permille = permille; LeaveCriticalSection(&g_lock); } static std::wstring shell_folder(int csidl) { wchar_t buf[MAX_PATH]; HRESULT hr = SHGetFolderPathW(nullptr, csidl | CSIDL_FLAG_CREATE, nullptr, SHGFP_TYPE_CURRENT, buf); if (FAILED(hr)) { log_fail(L"couldnt find shell folder " + num(csidl), (DWORD)hr); return L""; } return buf; } // the app name is a folder name and a shortcut name as well static std::wstring file_safe(const std::wstring& name) { std::wstring out; for (size_t i = 0; i < name.size(); i++) { wchar_t c = name[i]; if (c < 32 || wcschr(L"\\/:*?\"<>|", c)) continue; out += c; } while (!out.empty() && (out[out.size() - 1] == L' ' || out[out.size() - 1] == L'.')) out.resize(out.size() - 1); return out.empty() ? std::wstring(L"App") : out; } static std::wstring install_root(bool everyone) { std::wstring base = everyone ? shell_folder(CSIDL_PROGRAM_FILES) : join(shell_folder(CSIDL_LOCAL_APPDATA), L"Programs"); return join(base, file_safe(kAppName)); } static bool is_admin() { HANDLE token = nullptr; if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) return false; TOKEN_ELEVATION info = {}; DWORD size = 0; BOOL ok = GetTokenInformation(token, TokenElevation, &info, sizeof(info), &size); CloseHandle(token); return ok && info.TokenIsElevated != 0; } // the machine, not us. an x64 build of this runs fine on an arm64 pc and // should still ask for the arm64 app static const wchar_t* native_arch() { typedef BOOL (WINAPI *Wow64Fn)(HANDLE, USHORT*, USHORT*); HMODULE k32 = GetModuleHandleW(L"kernel32.dll"); Wow64Fn fn = k32 ? (Wow64Fn)(void*)GetProcAddress(k32, "IsWow64Process2") : nullptr; USHORT process = 0, machine = 0; if (fn && fn(GetCurrentProcess(), &process, &machine)) { return machine == 0xAA64 ? L"arm64" : L"x64"; } #if defined(_M_ARM64) || defined(__aarch64__) return L"arm64"; #else return L"x64"; #endif } // ---- http ---- struct Http { HINTERNET session = nullptr; HINTERNET conn = nullptr; HINTERNET req = nullptr; DWORD status = 0; }; static void http_end(Http& h) { DWORD keep = GetLastError(); if (h.req) WinHttpCloseHandle(h.req); if (h.conn) WinHttpCloseHandle(h.conn); if (h.session) WinHttpCloseHandle(h.session); h = Http(); SetLastError(keep); } // sends a GET and reads as far as the status. redirects are followed by // winhttp, and it carries the Range header along to wherever they lead static bool http_begin(Http& h, const std::wstring& url, long long from) { URL_COMPONENTS u = {}; u.dwStructSize = sizeof(u); u.dwSchemeLength = (DWORD)-1; u.dwHostNameLength = (DWORD)-1; u.dwUrlPathLength = (DWORD)-1; u.dwExtraInfoLength = (DWORD)-1; if (!WinHttpCrackUrl(url.c_str(), 0, 0, &u)) return false; std::wstring host(u.lpszHostName, u.dwHostNameLength); std::wstring path(u.lpszUrlPath, u.dwUrlPathLength); if (u.lpszExtraInfo) path.append(u.lpszExtraInfo, u.dwExtraInfoLength); if (path.empty()) path = L"/"; bool secure = u.nScheme == INTERNET_SCHEME_HTTPS; h.session = WinHttpOpen(kUserAgent, WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); if (!h.session) { // windows before 8.1 doesnt know that one h.session = WinHttpOpen(kUserAgent, WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); } if (!h.session) return false; DWORD tls = WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2; #ifdef WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_3 DWORD newer = tls | WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_3; if (!WinHttpSetOption(h.session, WINHTTP_OPTION_SECURE_PROTOCOLS, &newer, sizeof(newer))) #endif { if (!WinHttpSetOption(h.session, WINHTTP_OPTION_SECURE_PROTOCOLS, &tls, sizeof(tls))) { log_fail(L"couldnt pick the tls versions, using what windows defaults to", GetLastError()); } } WinHttpSetTimeouts(h.session, 15000, 15000, 30000, 30000); h.conn = WinHttpConnect(h.session, host.c_str(), u.nPort, 0); if (!h.conn) { http_end(h); return false; } h.req = WinHttpOpenRequest(h.conn, L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, secure ? WINHTTP_FLAG_SECURE : 0); if (!h.req) { http_end(h); return false; } if (from > 0) { std::wstring range = L"Range: bytes=" + num(from) + L"-"; if (!WinHttpAddRequestHeaders(h.req, range.c_str(), (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD)) { http_end(h); return false; } } if (!WinHttpSendRequest(h.req, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0) || !WinHttpReceiveResponse(h.req, nullptr)) { http_end(h); return false; } DWORD size = sizeof(h.status); if (!WinHttpQueryHeaders(h.req, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, WINHTTP_HEADER_NAME_BY_INDEX, &h.status, &size, WINHTTP_NO_HEADER_INDEX)) { http_end(h); return false; } return true; } static std::wstring http_header(Http& h, DWORD which) { wchar_t buf[256]; DWORD size = sizeof(buf); if (!WinHttpQueryHeaders(h.req, which, WINHTTP_HEADER_NAME_BY_INDEX, buf, &size, WINHTTP_NO_HEADER_INDEX)) { return L""; } return std::wstring(buf, size / sizeof(wchar_t)); } static bool http_text(const std::wstring& url, DWORD& status, std::string& body) { Http h; if (!http_begin(h, url, 0)) return false; status = h.status; body.clear(); char chunk[8192]; for (;;) { DWORD got = 0; if (!WinHttpReadData(h.req, chunk, sizeof(chunk), &got)) { http_end(h); return false; } if (got == 0) break; body.append(chunk, got); // its a few hundred bytes of json. anything like this isnt it if (body.size() > 1024 * 1024) break; } http_end(h); return true; } // ---- the release ---- struct Release { long long build = 0; std::wstring label; std::wstring url; std::wstring sha256; long long size = 0; }; static bool ask_garage(const wchar_t* arch, Release& out, bool& none, std::wstring& error) { none = false; std::wstring url = std::wstring(GARAGE_API_BASE) + L"/v1/updates/" + GARAGE_PROJECT_ID + L"?platform=windows&arch=" + arch; DWORD status = 0; std::string body; if (!http_text(url, status, body)) { DWORD err = GetLastError(); log_fail(L"couldnt ask " + url, err); error = L"Could not reach the download server. Check your internet connection.\n\n(" + win_error(err) + L")"; return false; } JVal json; bool parsed = json_parse(body, json) && json.kind == JVal::Obj; if (status != 200 || !parsed) { std::wstring said = parsed ? widen(json.str("message")) : L""; log_line(url + L" answered " + num(status) + L": " + widen(body.substr(0, 400))); error = L"The download server gave an answer that makes no sense (" + num(status) + L")."; if (!said.empty()) error += L"\n\n" + said; return false; } const JVal* latest = json.get("latest"); const JVal* asset = latest ? latest->get("asset") : nullptr; if (!latest || latest->kind != JVal::Obj || !asset || asset->kind != JVal::Obj) { none = true; return false; } out.build = latest->number("build", 0); out.label = widen(latest->str("label")); out.url = widen(asset->str("url")); out.sha256 = widen(asset->str("sha256")); out.size = asset->number("size", 0); std::string format = asset->str("format"); if (format != "zip") { log_line(L"the windows asset of build " + num(out.build) + L" is a " + widen(format) + L", it has to be a zip"); error = L"The newest release is not in a form this installer can use."; return false; } bool http = out.url.compare(0, 8, L"https://") == 0 || out.url.compare(0, 7, L"http://") == 0; if (out.build <= 0 || !http || out.sha256.size() != 64) { log_line(L"the release that came back is missing things: " + widen(body.substr(0, 400))); error = L"The download server gave an answer that makes no sense."; return false; } return true; } // one go at it. true is "the whole file is there". false with `again` set is // "ask once more, itll carry on from where this got to" static bool download_once(const Release& rel, const std::wstring& part, bool& again, std::wstring& error) { again = false; long long have = file_size(part); if (have < 0) have = 0; if (rel.size > 0 && have == rel.size) return true; if (rel.size > 0 && have > rel.size) { // not ours, or a different build that got the same name DeleteFileW(lp(part).c_str()); have = 0; } Http h; if (!http_begin(h, rel.url, have)) { DWORD err = GetLastError(); log_fail(L"couldnt start the download", err); error = L"The download could not be started. Check your internet connection.\n\n(" + win_error(err) + L")"; again = true; return false; } bool append = false; if (h.status == 206 && have > 0) { // "bytes 1000-1999/2000". if it isnt carrying on from where we are, start over std::wstring range = http_header(h, WINHTTP_QUERY_CONTENT_RANGE); std::wstring want = L"bytes " + num(have) + L"-"; append = range.compare(0, want.size(), want) == 0; if (!append) { log_line(L"asked to resume at " + num(have) + L" and got \"" + range + L"\", starting again"); http_end(h); DeleteFileW(lp(part).c_str()); again = true; return false; } } else if (h.status == 416) { // what we have is longer than the file is http_end(h); DeleteFileW(lp(part).c_str()); again = true; return false; } else if (h.status != 200) { log_line(L"the download answered " + num(h.status)); error = L"The download server refused the download (" + num(h.status) + L")."; again = h.status >= 500; http_end(h); return false; } else { // a plain 200 is the whole file from the top, whatever we asked for have = 0; } HANDLE file = CreateFileW(lp(part).c_str(), GENERIC_WRITE, FILE_SHARE_READ, nullptr, append ? OPEN_ALWAYS : CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (file == INVALID_HANDLE_VALUE) { DWORD err = GetLastError(); log_fail(L"couldnt open " + part, err); error = L"The download could not be saved.\n\n(" + win_error(err) + L")"; http_end(h); return false; } LARGE_INTEGER zero = {}; SetFilePointerEx(file, zero, nullptr, FILE_END); long long total = rel.size; std::vector buf(64 * 1024); bool ok = true; for (;;) { if (cancelled()) { ok = false; break; } DWORD got = 0; if (!WinHttpReadData(h.req, &buf[0], (DWORD)buf.size(), &got)) { DWORD err = GetLastError(); log_fail(L"the download broke off at " + num(have), err); error = L"The download was interrupted.\n\n(" + win_error(err) + L")"; again = true; ok = false; break; } if (got == 0) break; DWORD wrote = 0; if (!WriteFile(file, &buf[0], got, &wrote, nullptr) || wrote != got) { DWORD err = GetLastError(); log_fail(L"couldnt write to " + part, err); error = L"The download could not be saved. The disk may be full.\n\n(" + win_error(err) + L")"; ok = false; break; } have += got; if (total > 0) { int permille = (int)((have * 1000) / total); set_status(L"Downloading\x2026 " + num(have / (1024 * 1024)) + L" of " + num(total / (1024 * 1024)) + L" MB", permille > 1000 ? 1000 : permille); } else { set_status(L"Downloading\x2026 " + num(have / (1024 * 1024)) + L" MB", -1); } } CloseHandle(file); http_end(h); if (!ok) return false; if (total > 0 && have < total) { // the server hung up early without it being an error log_line(L"the download stopped at " + num(have) + L" of " + num(total)); error = L"The download was interrupted."; again = true; return false; } return true; } static bool download(const Release& rel, const std::wstring& part, std::wstring& error) { for (int attempt = 0; attempt < 5; attempt++) { bool again = false; if (download_once(rel, part, again, error)) return true; if (cancelled() || !again) return false; // a breath, then carry on from where it stopped. the Retry button is // for when this runs out Sleep(1500); } return false; } static bool sha256_file(const std::wstring& path, std::wstring& hex) { hex.clear(); HANDLE file = CreateFileW(lp(path).c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, nullptr); if (file == INVALID_HANDLE_VALUE) { log_fail(L"couldnt open " + path + L" to check it", GetLastError()); return false; } BCRYPT_ALG_HANDLE alg = nullptr; BCRYPT_HASH_HANDLE hash = nullptr; BYTE digest[32]; bool ok = false; LONG rc = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, nullptr, 0); if (rc >= 0) rc = BCryptCreateHash(alg, &hash, nullptr, 0, nullptr, 0, 0); if (rc >= 0) { std::vector buf(256 * 1024); long long total = file_size(path), done = 0; for (;;) { DWORD got = 0; if (!ReadFile(file, &buf[0], (DWORD)buf.size(), &got, nullptr)) { log_fail(L"couldnt read " + path + L" to check it", GetLastError()); rc = -1; break; } if (got == 0) break; rc = BCryptHashData(hash, &buf[0], got, 0); if (rc < 0) break; done += got; if (total > 0) set_status(L"Checking the download\x2026", (int)((done * 1000) / total)); } if (rc >= 0) rc = BCryptFinishHash(hash, digest, sizeof(digest), 0); ok = rc >= 0; } if (!ok) log_line(L"sha256 didnt work, ntstatus " + num((long long)rc)); if (hash) BCryptDestroyHash(hash); if (alg) BCryptCloseAlgorithmProvider(alg, 0); CloseHandle(file); if (!ok) return false; static const wchar_t digits[] = L"0123456789abcdef"; for (size_t i = 0; i < sizeof(digest); i++) { hex += digits[digest[i] >> 4]; hex += digits[digest[i] & 15]; } return true; } // ---- laying it out ---- // the stub comes out of our own resources and goes in under the apps exe name static bool write_stub(const std::wstring& to) { HMODULE me = GetModuleHandleW(nullptr); HRSRC res = FindResourceW(me, L"STUB", RT_RCDATA); HGLOBAL mem = res ? LoadResource(me, res) : nullptr; const void* bytes = mem ? LockResource(mem) : nullptr; DWORD size = res ? SizeofResource(me, res) : 0; if (!bytes || size == 0) { log_fail(L"the stub isnt inside this installer, it was built wrong", GetLastError()); return false; } std::wstring fresh = to + L".new"; HANDLE h = CreateFileW(lp(fresh).c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr); if (h == INVALID_HANDLE_VALUE) { log_fail(L"couldnt make " + fresh, GetLastError()); return false; } DWORD wrote = 0; bool ok = WriteFile(h, bytes, size, &wrote, nullptr) && wrote == size; DWORD err = GetLastError(); CloseHandle(h); if (!ok) { log_fail(L"couldnt write " + fresh, err); DeleteFileW(lp(fresh).c_str()); return false; } // installing over the top of one thats there. the old stub is only ever // running for the moment it takes to start the app for (int i = 0; i < 15; i++) { if (MoveFileExW(lp(fresh).c_str(), lp(to).c_str(), MOVEFILE_REPLACE_EXISTING)) return true; err = GetLastError(); Sleep(300); } log_fail(L"couldnt put the stub at " + to, err); DeleteFileW(lp(fresh).c_str()); return false; } static bool make_shortcut(const std::wstring& lnk, const std::wstring& target, const std::wstring& dir) { IShellLinkW* link = nullptr; HRESULT hr = CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER, IID_IShellLinkW, (void**)&link); if (FAILED(hr) || !link) { log_fail(L"couldnt make a shortcut object for " + lnk, (DWORD)hr); return false; } link->SetPath(target.c_str()); link->SetWorkingDirectory(dir.c_str()); link->SetDescription(kAppName); link->SetIconLocation(target.c_str(), 0); IPersistFile* file = nullptr; hr = link->QueryInterface(IID_IPersistFile, (void**)&file); if (SUCCEEDED(hr) && file) { hr = file->Save(lnk.c_str(), TRUE); file->Release(); } link->Release(); if (FAILED(hr)) { log_fail(L"couldnt save " + lnk, (DWORD)hr); return false; } return true; } static long long folder_size(const std::wstring& dir) { long long total = 0; WIN32_FIND_DATAW fd; HANDLE find = FindFirstFileW(lp(join(dir, L"*")).c_str(), &fd); if (find == INVALID_HANDLE_VALUE) return 0; do { std::wstring name = fd.cFileName; if (name == L"." || name == L"..") continue; if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) total += folder_size(join(dir, name)); } else { total += ((long long)fd.nFileSizeHigh << 32) | (long long)fd.nFileSizeLow; } } while (FindNextFileW(find, &fd)); FindClose(find); return total; } static bool reg_text(HKEY key, const wchar_t* name, const std::wstring& value) { LSTATUS rc = RegSetValueExW(key, name, 0, REG_SZ, (const BYTE*)value.c_str(), (DWORD)((value.size() + 1) * sizeof(wchar_t))); if (rc != ERROR_SUCCESS) log_fail(std::wstring(L"couldnt set ") + name + L" on the uninstall entry", (DWORD)rc); return rc == ERROR_SUCCESS; } static bool reg_number(HKEY key, const wchar_t* name, DWORD value) { LSTATUS rc = RegSetValueExW(key, name, 0, REG_DWORD, (const BYTE*)&value, sizeof(value)); if (rc != ERROR_SUCCESS) log_fail(std::wstring(L"couldnt set ") + name + L" on the uninstall entry", (DWORD)rc); return rc == ERROR_SUCCESS; } // the line in "installed apps". its also where the stub finds out what to // take away again: it looks for the entry whose InstallLocation is its own // folder and deletes the shortcuts listed in GarageShortcuts static bool write_uninstall_entry(const std::wstring& root, const std::wstring& stub, const Release& rel, const std::vector& shortcuts) { std::wstring path = std::wstring(L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\") + GARAGE_APP_ID; HKEY key = nullptr; LSTATUS rc = RegCreateKeyExW(g_everyone ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER, path.c_str(), 0, nullptr, 0, KEY_WRITE | KEY_WOW64_64KEY, nullptr, &key, nullptr); if (rc != ERROR_SUCCESS) { log_fail(L"couldnt make the uninstall entry", (DWORD)rc); return false; } SYSTEMTIME t; GetLocalTime(&t); wchar_t date[16]; wsprintfW(date, L"%04d%02d%02d", t.wYear, t.wMonth, t.wDay); std::wstring multi; for (size_t i = 0; i < shortcuts.size(); i++) { multi += shortcuts[i]; multi += L'\0'; } multi += L'\0'; bool ok = true; ok = reg_text(key, L"DisplayName", kAppName) && ok; ok = reg_text(key, L"DisplayVersion", rel.label.empty() ? num(rel.build) : rel.label) && ok; ok = reg_text(key, L"DisplayIcon", stub) && ok; ok = reg_text(key, L"InstallLocation", root) && ok; ok = reg_text(key, L"InstallDate", date) && ok; ok = reg_text(key, L"UninstallString", quote_arg(stub) + L" --garage-uninstall") && ok; ok = reg_text(key, L"QuietUninstallString", quote_arg(stub) + L" --garage-uninstall --quiet") && ok; if (kPublisher[0]) ok = reg_text(key, L"Publisher", kPublisher) && ok; ok = reg_number(key, L"NoModify", 1) && ok; ok = reg_number(key, L"NoRepair", 1) && ok; ok = reg_number(key, L"EstimatedSize", (DWORD)(folder_size(version_dir(root, rel.build)) / 1024)) && ok; rc = RegSetValueExW(key, L"GarageShortcuts", 0, REG_MULTI_SZ, (const BYTE*)multi.data(), (DWORD)(multi.size() * sizeof(wchar_t))); if (rc != ERROR_SUCCESS) { log_fail(L"couldnt set GarageShortcuts on the uninstall entry", (DWORD)rc); ok = false; } RegCloseKey(key); return ok; } static std::wstring g_errorText; static bool fail(const std::wstring& text) { g_errorText = text; return false; } // everything, start to finish. runs on the worker thread static bool install() { std::wstring error; set_status(L"Looking for the newest version\x2026", -1); const wchar_t* arch = native_arch(); Release rel; bool none = false; if (!ask_garage(arch, rel, none, error)) { if (!none) return fail(error); // nothing built for arm. the x64 one runs there all the same bool found = false; if (lstrcmpW(arch, L"arm64") == 0) { found = ask_garage(L"x64", rel, none, error); if (!found && !none) return fail(error); } if (!found) { log_line(std::wstring(L"garage has no published windows release for ") + arch); return fail(std::wstring(kAppName) + L" has not been released for Windows yet."); } } if (cancelled()) return false; std::wstring zip = join(g_logDir, num(rel.build) + L".zip"); std::wstring part = zip + L".part"; if (!exists(zip)) { set_status(L"Downloading\x2026", rel.size > 0 ? 0 : -1); if (!download(rel, part, error)) return fail(error); if (cancelled()) return false; if (!MoveFileExW(lp(part).c_str(), lp(zip).c_str(), MOVEFILE_REPLACE_EXISTING)) { DWORD err = GetLastError(); log_fail(L"couldnt rename " + part, err); return fail(L"The download could not be saved.\n\n(" + win_error(err) + L")"); } } set_status(L"Checking the download\x2026", 0); std::wstring sum; if (!sha256_file(zip, sum)) return fail(L"The download could not be checked."); if (!same_text(sum, rel.sha256)) { log_line(L"sha256 of the download is " + sum + L", garage says " + rel.sha256); // no good to anybody. Retry starts it from nothing DeleteFileW(lp(zip).c_str()); return fail(L"The download arrived damaged. Try again."); } if (cancelled()) return false; set_status(L"Installing\x2026", -1); std::wstring root = install_root(g_everyone); int made = SHCreateDirectoryExW(nullptr, root.c_str(), nullptr); if (made != ERROR_SUCCESS && made != ERROR_ALREADY_EXISTS && made != ERROR_FILE_EXISTS) { log_fail(L"couldnt make " + root, (DWORD)made); return fail(L"The install folder could not be made.\n\n" + root + L"\n(" + win_error((DWORD)made) + L")"); } std::wstring stub = join(root, GARAGE_EXE_NAME); if (!write_stub(stub)) return fail(L"The app could not be copied in to place.\n\n" + root); // the stub needs to know which exe in the zip is the app before its // unpacked anything. whatever else is in an old state file stays State st; std::string text; if (read_file(state_path(root), text, 1024 * 1024) && !parse_state(text, st)) { log_line(L"the state file in " + root + L" wont read, writing a new one"); st = State(); } st.exe = GARAGE_EXE_NAME; st.set_extra("app_id", GARAGE_APP_ID); if (!write_atomic(state_path(root), print_state(st))) { DWORD err = GetLastError(); log_fail(L"couldnt write " + state_path(root), err); return fail(L"The install folder could not be written to.\n\n" + root + L"\n(" + win_error(err) + L")"); } DWORD code = 1; if (!run_wait(stub, L"--garage-apply " + quote_arg(zip) + L" " + num(rel.build), root, nullptr, code)) { DWORD err = GetLastError(); log_fail(L"couldnt run " + stub, err); return fail(L"The app could not be unpacked.\n\n(" + win_error(err) + L")"); } if (code != 0) { log_line(L"the stub couldnt unpack build " + num(rel.build) + L", it exited " + num(code)); return fail(L"The app could not be unpacked (code " + num(code) + L").\n\nDetails are in " + join(root, L"garage_updates.log")); } // from here its in and it runs. a shortcut that wont save is logged and // lived with, its not worth telling somebody the install failed over std::vector shortcuts; HRESULT com = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); std::wstring lnkName = file_safe(kAppName) + L".lnk"; std::wstring programs = shell_folder(g_everyone ? CSIDL_COMMON_PROGRAMS : CSIDL_PROGRAMS); if (!programs.empty() && make_shortcut(join(programs, lnkName), stub, root)) { shortcuts.push_back(join(programs, lnkName)); } if (g_desktopShortcut) { std::wstring desktop = shell_folder(g_everyone ? CSIDL_COMMON_DESKTOPDIRECTORY : CSIDL_DESKTOPDIRECTORY); if (!desktop.empty() && make_shortcut(join(desktop, lnkName), stub, root)) { shortcuts.push_back(join(desktop, lnkName)); } } if (SUCCEEDED(com)) CoUninitialize(); if (!write_uninstall_entry(root, stub, rel, shortcuts)) { log_line(L"the uninstall entry is missing or half there, the app is installed all the same"); } if (!DeleteFileW(lp(zip).c_str())) log_fail(L"couldnt delete " + zip, GetLastError()); return true; } static DWORD WINAPI install_thread(LPVOID) { g_errorText.clear(); bool ok = install(); EnterCriticalSection(&g_lock); g_progress.ok = ok; g_progress.error = g_errorText; g_progress.done = true; LeaveCriticalSection(&g_lock); return 0; } static bool start_app() { std::wstring root = install_root(g_everyone); std::wstring stub = join(root, GARAGE_EXE_NAME); std::wstring cmd = quote_arg(stub); STARTUPINFOW si = {}; si.cb = sizeof(si); PROCESS_INFORMATION pi = {}; if (!CreateProcessW(stub.c_str(), &cmd[0], nullptr, nullptr, FALSE, 0, nullptr, root.c_str(), &si, &pi)) { log_fail(L"installed, but couldnt start " + stub, GetLastError()); return false; } CloseHandle(pi.hThread); CloseHandle(pi.hProcess); return true; } // ourselves again, behind the uac prompt. the handle comes back so whoever // asked can wait for it static bool relaunch_elevated(HWND owner) { wchar_t self[MAX_PATH * 4]; DWORD n = GetModuleFileNameW(nullptr, self, ARRAYSIZE(self)); if (n == 0 || n >= ARRAYSIZE(self)) { log_fail(L"couldnt find our own exe to elevate", GetLastError()); return false; } SHELLEXECUTEINFOW sx = {}; sx.cbSize = sizeof(sx); sx.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_NOASYNC; sx.hwnd = owner; sx.lpVerb = L"runas"; sx.lpFile = self; sx.lpParameters = L"--everyone --elevated"; sx.nShow = SW_SHOWNORMAL; if (!ShellExecuteExW(&sx) || !sx.hProcess) { log_fail(L"the administrator prompt was turned down, or didnt come up", GetLastError()); return false; } g_child = sx.hProcess; return true; } // ---- the window ---- static std::wstring g_title, g_heading, g_body; static TASKDIALOGCONFIG g_cfg; static TASKDIALOG_BUTTON g_buttons[1]; static TASKDIALOG_BUTTON g_radios[2]; static HRESULT CALLBACK dialog_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LONG_PTR data); // fills g_cfg for a page. everything it points at is a global, the dialog // holds on to the pointers static void fill_page(Page page) { g_page = page; g_cfg = TASKDIALOGCONFIG(); g_cfg.cbSize = sizeof(g_cfg); g_cfg.hInstance = GetModuleHandleW(nullptr); g_cfg.pfCallback = dialog_proc; g_cfg.dwFlags = TDF_ALLOW_DIALOG_CANCELLATION | TDF_CAN_BE_MINIMIZED; g_title = std::wstring(kAppName) + L" Setup"; g_cfg.pszWindowTitle = g_title.c_str(); if (page == PAGE_ERROR) { g_cfg.pszMainIcon = TD_ERROR_ICON; } else if (g_icon) { g_cfg.dwFlags |= TDF_USE_HICON_MAIN; g_cfg.hMainIcon = g_icon; } switch (page) { case PAGE_CHOICE: g_heading = std::wstring(L"Install ") + kAppName; g_body = L"Who should be able to use it?"; g_buttons[0].nButtonID = ID_INSTALL; g_buttons[0].pszButtonText = L"Install"; g_radios[0].nButtonID = RADIO_ME; g_radios[0].pszButtonText = L"Just me"; g_radios[1].nButtonID = RADIO_EVERYONE; g_radios[1].pszButtonText = L"Everyone on this PC"; g_cfg.pButtons = g_buttons; g_cfg.cButtons = 1; g_cfg.pRadioButtons = g_radios; g_cfg.cRadioButtons = 2; g_cfg.nDefaultRadioButton = g_everyone ? RADIO_EVERYONE : RADIO_ME; g_cfg.nDefaultButton = ID_INSTALL; g_cfg.dwCommonButtons = TDCBF_CANCEL_BUTTON; break; case PAGE_PROGRESS: g_heading = std::wstring(L"Installing ") + kAppName; g_body = L"Getting ready\x2026"; g_cfg.dwFlags |= TDF_SHOW_PROGRESS_BAR | TDF_CALLBACK_TIMER; g_cfg.dwCommonButtons = TDCBF_CANCEL_BUTTON; break; case PAGE_ERROR: g_heading = std::wstring(kAppName) + L" could not be installed"; g_cfg.dwCommonButtons = TDCBF_RETRY_BUTTON | TDCBF_CLOSE_BUTTON; g_cfg.nDefaultButton = IDRETRY; break; } g_cfg.pszMainInstruction = g_heading.c_str(); g_cfg.pszContent = g_body.c_str(); } static void go_to(HWND hwnd, Page page) { fill_page(page); SendMessageW(hwnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&g_cfg); } static void set_body(HWND hwnd, const std::wstring& text) { g_body = text; SendMessageW(hwnd, TDM_SET_ELEMENT_TEXT, TDE_CONTENT, (LPARAM)g_body.c_str()); } static void show_shield(HWND hwnd) { SendMessageW(hwnd, TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE, ID_INSTALL, g_everyone && !is_admin()); } static void set_marquee(HWND hwnd, bool on) { g_marquee = on; SendMessageW(hwnd, TDM_SET_MARQUEE_PROGRESS_BAR, on, 0); SendMessageW(hwnd, TDM_SET_PROGRESS_BAR_MARQUEE, on, 0); } static void start_worker(HWND hwnd) { EnterCriticalSection(&g_lock); g_progress.status = g_body; g_progress.permille = -1; g_progress.done = false; g_progress.ok = false; g_progress.error.clear(); LeaveCriticalSection(&g_lock); InterlockedExchange(&g_cancel, 0); g_shown = g_body; SendMessageW(hwnd, TDM_SET_PROGRESS_BAR_RANGE, 0, MAKELPARAM(0, 1000)); set_marquee(hwnd, true); g_worker = CreateThread(nullptr, 0, install_thread, nullptr, 0, nullptr); if (!g_worker) { log_fail(L"couldnt start the install thread", GetLastError()); g_body = L"Windows would not start the install. Try again."; go_to(hwnd, PAGE_ERROR); } } // five times a second while the progress page is up static void on_tick(HWND hwnd) { if (!g_worker) return; EnterCriticalSection(&g_lock); std::wstring status = g_progress.status; int permille = g_progress.permille; bool done = g_progress.done, ok = g_progress.ok; std::wstring error = g_progress.error; LeaveCriticalSection(&g_lock); if (!done) { if (cancelled()) return; if (status != g_shown) { g_shown = status; set_body(hwnd, status); } if (permille < 0) { if (!g_marquee) set_marquee(hwnd, true); } else { if (g_marquee) set_marquee(hwnd, false); SendMessageW(hwnd, TDM_SET_PROGRESS_BAR_POS, (WPARAM)permille, 0); } return; } WaitForSingleObject(g_worker, INFINITE); CloseHandle(g_worker); g_worker = nullptr; if (ok || cancelled()) { g_exit = ok ? kExitOk : kExitCancelled; // with the worker gone a click on cancel is let through, which is // how a task dialog gets closed from the inside SendMessageW(hwnd, TDM_CLICK_BUTTON, IDCANCEL, 0); return; } g_body = error.empty() ? std::wstring(L"Something went wrong.") : error; go_to(hwnd, PAGE_ERROR); } // S_OK lets the click close the dialog, S_FALSE keeps it open static HRESULT on_button(HWND hwnd, int id) { switch (g_page) { case PAGE_CHOICE: if (id != ID_INSTALL) { g_exit = kExitCancelled; return S_OK; } if (g_everyone && !is_admin()) { if (relaunch_elevated(hwnd)) return S_OK; set_body(hwnd, L"Installing for everyone needs an administrator to allow it. " L"Choose Just me to install without one."); return S_FALSE; } go_to(hwnd, PAGE_PROGRESS); return S_FALSE; case PAGE_PROGRESS: if (!g_worker) return S_OK; // the worker is told, and the timer closes us once its let go InterlockedExchange(&g_cancel, 1); set_body(hwnd, L"Cancelling\x2026"); return S_FALSE; case PAGE_ERROR: if (id == IDRETRY) { go_to(hwnd, PAGE_PROGRESS); return S_FALSE; } g_exit = kExitFailed; return S_OK; } return S_OK; } static HRESULT CALLBACK dialog_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM, LONG_PTR) { switch (msg) { case TDN_CREATED: case TDN_NAVIGATED: if (g_page == PAGE_CHOICE) show_shield(hwnd); if (g_page == PAGE_PROGRESS) start_worker(hwnd); break; case TDN_RADIO_BUTTON_CLICKED: g_everyone = (int)wp == RADIO_EVERYONE; show_shield(hwnd); break; case TDN_TIMER: on_tick(hwnd); break; case TDN_BUTTON_CLICKED: return on_button(hwnd, (int)wp); } return S_OK; } static void complain(const std::wstring& text) { MessageBoxW(nullptr, text.c_str(), (std::wstring(kAppName) + L" Setup").c_str(), MB_OK | MB_ICONERROR | MB_SETFOREGROUND); } int WINAPI wWinMain(HINSTANCE inst, HINSTANCE, PWSTR, int) { InitializeCriticalSection(&g_lock); wchar_t temp[MAX_PATH + 2]; DWORD n = GetTempPathW(ARRAYSIZE(temp), temp); if (n > 0 && n < ARRAYSIZE(temp)) { g_logDir = join(temp, std::wstring(GARAGE_APP_ID) + L"-setup"); if (!CreateDirectoryW(lp(g_logDir).c_str(), nullptr) && GetLastError() != ERROR_ALREADY_EXISTS) { DWORD err = GetLastError(); g_logDir = std::wstring(temp); log_fail(L"couldnt make a folder in temp, using temp itself", err); } } else { complain(L"Windows has no temporary folder to download to."); return kExitFailed; } int argc = 0; wchar_t** argv = CommandLineToArgvW(GetCommandLineW(), &argc); for (int i = 1; argv && i < argc; i++) { if (lstrcmpW(argv[i], L"--everyone") == 0) g_everyone = true; if (lstrcmpW(argv[i], L"--just-me") == 0) g_everyone = false; if (lstrcmpW(argv[i], L"--elevated") == 0) g_elevatedChild = true; } if (argv) LocalFree(argv); g_icon = LoadIconW(inst, MAKEINTRESOURCEW(1)); bool choose = g_showChoice && !g_elevatedChild; if (!choose && g_everyone && !is_admin()) { // nothing to ask and its going in program files, so straight to the prompt if (!relaunch_elevated(nullptr)) { complain(std::wstring(kAppName) + L" is installed for everyone on this PC, which needs an administrator to allow it."); return kExitCancelled; } } if (!g_child) { fill_page(choose ? PAGE_CHOICE : PAGE_PROGRESS); int pressed = 0; HRESULT hr = TaskDialogIndirect(&g_cfg, &pressed, nullptr, nullptr); if (FAILED(hr)) { log_fail(L"the setup window wouldnt open", (DWORD)hr); complain(L"The setup window could not be opened."); return kExitFailed; } } if (g_child) { // the elevated one has its own window and its own retry. we only // want to know how it ended WaitForSingleObject(g_child, INFINITE); DWORD code = (DWORD)kExitFailed; GetExitCodeProcess(g_child, &code); CloseHandle(g_child); g_exit = (int)code; } // an elevated copy doesnt start the app, or the app would run as admin. // the one that asked for it does, back down here as the user if (g_exit == kExitOk && !g_elevatedChild) start_app(); DeleteCriticalSection(&g_lock); return g_exit; }