comphelper/source/windows/windows_process.cxx

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #define WIN32_LEAN_AND_MEAN
   6 #include <windows.h>
   7
   8 #include <cstring>
   9 #include <wchar.h>
  10
  11 #include <comphelper/windowsStart.hxx>
  12
  13 // Needed for CreateEnvironmentBlock
  14 #include <userenv.h>
  15 #pragma comment(lib, "userenv.lib")
  16
  17 /**
  18  * Get the length that the string will take and takes into account the
  19  * additional length if the string needs to be quoted and if characters need to
  20  * be escaped.
  21  */
  22 static int ArgStrLen(const wchar_t *s)
  23 {
  24     int i = wcslen(s);
  25     bool hasDoubleQuote = wcschr(s, L'"') != nullptr;
  26     // Only add doublequotes if the string contains a space or a tab
  27     bool addDoubleQuotes = wcspbrk(s, L" \t") != nullptr;
  28
  29     if (addDoubleQuotes)
  30     {
  31         i += 2; // initial and final doublequote
  32     }
  33
  34     if (hasDoubleQuote)
  35     {
  36         int backslashes = 0;
  37         while (*s)
  38         {
  39             if (*s == '\\')
  40             {
  41                 ++backslashes;
  42             }
  43             else
  44             {
  45                 if (*s == '"')
  46                 {
  47                     // Escape the doublequote and all backslashes preceding the doublequote
  48                     i += backslashes + 1;
  49                 }
  50
  51                 backslashes = 0;
  52             }
  53
  54             ++s;
  55         }
  56     }
  57
  58     return i;
  59 }
  60
  61 /**
  62  * Copy string "s" to string "d", quoting the argument as appropriate and
  63  * escaping doublequotes along with any backslashes that immediately precede
  64  * doublequotes.
  65  * The CRT parses this to retrieve the original argc/argv that we meant,
  66  * see STDARGV.C in the MSVC CRT sources.
  67  *
  68  * @return the end of the string
  69  */
  70 static wchar_t* ArgToString(wchar_t *d, const wchar_t *s)
  71 {
  72     bool hasDoubleQuote = wcschr(s, L'"') != nullptr;
  73     // Only add doublequotes if the string contains a space or a tab
  74     bool addDoubleQuotes = wcspbrk(s, L" \t") != nullptr;
  75
  76     if (addDoubleQuotes)
  77     {
  78         *d = '"'; // initial doublequote
  79         ++d;
  80     }
  81
  82     if (hasDoubleQuote)
  83     {
  84         int backslashes = 0;
  85         while (*s)
  86         {
  87             if (*s == '\\')
  88             {
  89                 ++backslashes;
  90             }
  91             else
  92             {
  93                 if (*s == '"')
  94                 {
  95                     // Escape the doublequote and all backslashes preceding the doublequote
  96                     for (int i = 0; i <= backslashes; ++i)
  97                     {
  98                         *d = '\\';
  99                         ++d;
 100                     }
 101                 }
 102
 103                 backslashes = 0;
 104             }
 105
 106             *d = *s;
 107             ++d;
 108             ++s;
 109         }
 110     }
 111     else
 112     {
 113         wcscpy(d, s);
 114         d += wcslen(s);
 115     }
 116
 117     if (addDoubleQuotes)
 118     {
 119         *d = '"'; // final doublequote
 120         ++d;
 121     }
 122
 123     return d;
 124 }
 125
 126 /**
 127  * Creates a command line from a list of arguments. The returned
 128  * string is allocated with "malloc" and should be "free"d.
 129  */
 130 static wchar_t* MakeCommandLine(wchar_t **argv)
 131 {
 132     int i;
 133     int len = 0;
 134
 135     // The + 1 of the last argument handles the allocation for null termination
 136     for (i = 0; argv[i]; ++i)
 137         len += ArgStrLen(argv[i]) + 1;
 138
 139     // Protect against callers that pass 0 arguments
 140     if (len == 0)
 141         len = 1;
 142
 143     wchar_t *s = static_cast<wchar_t*>(malloc(len * sizeof(wchar_t)));
 144     if (!s)
 145         return nullptr;
 146
 147     wchar_t *c = s;
 148     for (i = 0; argv[i]; ++i)
 149     {
 150         c = ArgToString(c, argv[i]);
 151         if (argv[i + 1])
 152         {
 153             *c = ' ';
 154             ++c;
 155         }
 156     }
 157
 158     *c = '\0';
 159
 160     return s;
 161 }
 162
 163 BOOL
 164 WinLaunchChild(const wchar_t *exePath,
 165                wchar_t **argv,
 166                HANDLE userToken,
 167                HANDLE *hProcess)
 168 {
 169     wchar_t *cl;
 170     bool ok;
 171
 172     cl = MakeCommandLine(argv);
 173     if (!cl)
 174     {
 175         return FALSE;
 176     }
 177
 178     STARTUPINFOW si{ .cb = sizeof(si), .lpDesktop = const_cast<LPWSTR>(L"winsta0\\Default") };
 179     PROCESS_INFORMATION pi{};
 180
 181     if (userToken == nullptr)
 182     {
 183         ok = CreateProcessW(exePath,
 184                             cl,
 185                             nullptr,  // no special security attributes
 186                             nullptr,  // no special thread attributes
 187                             FALSE, // don't inherit filehandles
 188                             0,     // creation flags
 189                             nullptr,  // inherit my environment
 190                             nullptr,  // use my current directory
 191                             &si,
 192                             &pi);
 193     }
 194     else
 195     {
 196         // Create an environment block for the process we're about to start using
 197         // the user's token.
 198         LPVOID environmentBlock = nullptr;
 199         if (!CreateEnvironmentBlock(&environmentBlock, userToken, TRUE))
 200         {
 201             environmentBlock = nullptr;
 202         }
 203
 204         ok = CreateProcessAsUserW(userToken,
 205                                   exePath,
 206                                   cl,
 207                                   nullptr,  // no special security attributes
 208                                   nullptr,  // no special thread attributes
 209                                   FALSE,    // don't inherit filehandles
 210                                   0,        // creation flags
 211                                   environmentBlock,
 212                                   nullptr,  // use my current directory
 213                                   &si,
 214                                   &pi);
 215
 216         if (environmentBlock)
 217         {
 218             DestroyEnvironmentBlock(environmentBlock);
 219         }
 220     }
 221
 222     if (ok)
 223     {
 224         if (hProcess)
 225         {
 226             *hProcess = pi.hProcess; // the caller now owns the HANDLE
 227         }
 228         else
 229         {
 230             CloseHandle(pi.hProcess);
 231         }
 232         CloseHandle(pi.hThread);
 233     }
 234     else
 235     {
 236         LPWSTR lpMsgBuf = nullptr;
 237         FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
 238                        FORMAT_MESSAGE_FROM_SYSTEM |
 239                        FORMAT_MESSAGE_IGNORE_INSERTS,
 240                        nullptr,
 241                        GetLastError(),
 242                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 243                        reinterpret_cast<LPWSTR>(&lpMsgBuf),
 244                        0,
 245                        nullptr);
 246         wprintf(L"Error restarting: %s\n", lpMsgBuf ? lpMsgBuf : L"(null)");
 247         if (lpMsgBuf)
 248             HeapFree(GetProcessHeap(), 0, lpMsgBuf);
 249     }
 250
 251     free(cl);
 252
 253     return ok;
 254 }