external/onlineupdate/install_updateservice.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11
  12 #include <algorithm>
  13 #include <cstddef>
  14 #include <limits>
  15 #include <memory>
  16 #include <string>
  17
  18 #define WIN32_LEAN_AND_MEAN
  19 #include <windows.h>
  20 #include <msiquery.h>
  21
  22 #include <pathhash.h>
  23
  24 // Replacements for functions used in
  25 // workdir/UnpackedTarball/onlineupdate/onlineupdate/source/update/common/pathhash.cpp but not
  26 // available here:
  27
  28 extern "C" wchar_t* _wcslwr(wchar_t* str)
  29 {
  30     for (auto p = str; *p != L'\0'; ++p)
  31     {
  32         if (*p >= L'A' && *p <= L'Z')
  33         {
  34             *p += L'a' - L'A';
  35         }
  36     }
  37     return str;
  38 };
  39
  40 extern "C" wchar_t* wcsncpy(wchar_t* strDest, wchar_t const* strSource, std::size_t count)
  41 {
  42     for (std::size_t i = 0; i != count; ++i)
  43     {
  44         strDest[i] = *strSource;
  45         if (*strSource != L'\0')
  46         {
  47             ++strSource;
  48         }
  49     }
  50     return strDest;
  51 }
  52
  53 namespace
  54 {
  55 bool getProperty(MSIHANDLE handle, wchar_t const* name, std::wstring* value)
  56 {
  57     DWORD n = 0;
  58     if (MsiGetPropertyW(handle, name, const_cast<wchar_t*>(L""), &n) != ERROR_MORE_DATA
  59         || n == std::numeric_limits<DWORD>::max())
  60     {
  61         return false;
  62     }
  63     ++n;
  64     auto buf = std::make_unique<wchar_t[]>(n);
  65     if (MsiGetPropertyW(handle, name, buf.get(), &n) != ERROR_SUCCESS)
  66     {
  67         return false;
  68     }
  69     if (n != 0 && buf[n - 1] == L'\\')
  70     {
  71         --n;
  72     }
  73     value->assign(buf.get(), n);
  74     return true;
  75 }
  76
  77 typedef std::unique_ptr<void, decltype(&CloseHandle)> CloseHandleGuard;
  78
  79 CloseHandleGuard guard(HANDLE handle) { return CloseHandleGuard(handle, CloseHandle); }
  80
  81 bool runExecutable(std::wstring const& installLocation, wchar_t const* argument)
  82 {
  83     std::wstring cmdline(L"\"");
  84     cmdline += installLocation;
  85     cmdline += L"\\program\\update_service.exe\" ";
  86     cmdline += argument;
  87     auto const n = cmdline.size() + 1;
  88     auto const buf = std::make_unique<wchar_t[]>(n);
  89     std::copy_n(cmdline.data(), n, buf.get());
  90     STARTUPINFOW si{};
  91     si.cb = sizeof(si);
  92     PROCESS_INFORMATION pi{};
  93     if (!CreateProcessW(nullptr, buf.get(), nullptr, nullptr, FALSE, CREATE_NO_WINDOW, nullptr,
  94                         nullptr, &si, &pi))
  95     {
  96         return false;
  97     }
  98     auto const g(guard(pi.hProcess));
  99     DWORD res = WaitForSingleObject(pi.hProcess, INFINITE);
 100     if (res != WAIT_OBJECT_0)
 101     {
 102         return false;
 103     }
 104     DWORD ec = 0;
 105     if (!GetExitCodeProcess(pi.hProcess, &ec))
 106     {
 107         return false;
 108     }
 109     if (ec != 0)
 110     {
 111         return false;
 112     }
 113     return true;
 114 }
 115
 116 bool writeRegistry(std::wstring const& installLocation)
 117 {
 118     WCHAR path[MAX_PATH + 1];
 119     if (!CalculateRegistryPathFromFilePath(installLocation.c_str(), path))
 120     {
 121         return false;
 122     }
 123     HKEY key;
 124     if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, (std::wstring(path) + L"\\0").c_str(), 0, nullptr,
 125                         REG_OPTION_NON_VOLATILE, KEY_WRITE | KEY_WOW64_64KEY, nullptr, &key,
 126                         nullptr)
 127         != ERROR_SUCCESS)
 128     {
 129         return false;
 130     }
 131     auto ok = true;
 132     if (RegSetValueExW(key, L"issuer", 0, REG_SZ,
 133                        reinterpret_cast<BYTE const*>(L"Certum Code Signing 2021 CA"),
 134                        sizeof L"Certum Code Signing 2021 CA")
 135         != ERROR_SUCCESS)
 136     {
 137         ok = false;
 138     }
 139     if (RegSetValueExW(key, L"name", 0, REG_SZ,
 140                        reinterpret_cast<BYTE const*>(L"The Document Foundation"),
 141                        sizeof L"The Document Foundation")
 142         != ERROR_SUCCESS)
 143     {
 144         ok = false;
 145     }
 146     if (RegCloseKey(key) != ERROR_SUCCESS)
 147     {
 148         ok = false;
 149     }
 150     return ok;
 151 }
 152
 153 bool deleteRegistry(std::wstring const& installLocation)
 154 {
 155     WCHAR path[MAX_PATH + 1];
 156     if (!CalculateRegistryPathFromFilePath(installLocation.c_str(), path))
 157     {
 158         return false;
 159     }
 160     if (RegDeleteTreeW(HKEY_LOCAL_MACHINE, path) != ERROR_SUCCESS)
 161     {
 162         return false;
 163     }
 164     return true;
 165 }
 166 }
 167
 168 extern "C" __declspec(dllexport) UINT __stdcall PrepareUpdateservice(MSIHANDLE handle)
 169 {
 170     std::wstring loc;
 171     if (!getProperty(handle, L"INSTALLLOCATION", &loc))
 172     {
 173         return ERROR_INSTALL_FAILURE;
 174     }
 175     auto ok = true;
 176     if (MsiSetPropertyW(handle, L"install_updateservice", loc.c_str()) != ERROR_SUCCESS)
 177     {
 178         ok = false;
 179     }
 180     if (MsiSetPropertyW(handle, L"uninstall_updateservice", loc.c_str()) != ERROR_SUCCESS)
 181     {
 182         ok = false;
 183     }
 184     return ok ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;
 185 }
 186
 187 extern "C" __declspec(dllexport) UINT __stdcall InstallUpdateservice(MSIHANDLE handle)
 188 {
 189     std::wstring loc;
 190     if (!getProperty(handle, L"CustomActionData", &loc))
 191     {
 192         return ERROR_INSTALL_FAILURE;
 193     }
 194     auto ok = true;
 195     if (!runExecutable(loc, L"install"))
 196     {
 197         ok = false;
 198     }
 199     if (!writeRegistry(loc))
 200     {
 201         ok = false;
 202     }
 203     return ok ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;
 204 }
 205
 206 extern "C" __declspec(dllexport) UINT __stdcall UninstallUpdateservice(MSIHANDLE handle)
 207 {
 208     std::wstring loc;
 209     if (!getProperty(handle, L"CustomActionData", &loc))
 210     {
 211         return ERROR_INSTALL_FAILURE;
 212     }
 213     auto ok = true;
 214     if (!runExecutable(loc, L"uninstall"))
 215     {
 216         ok = false;
 217     }
 218     if (!deleteRegistry(loc))
 219     {
 220         ok = false;
 221     }
 222     return ok ? ERROR_SUCCESS : ERROR_INSTALL_FAILURE;
 223 }
 224
 225 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */