desktop/win32/source/officeloader/officeloader.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #define UNICODE
  21 #define _UNICODE
  22
  23 #include <cstddef>
  24 #include <cwchar>
  25
  26 #define WIN32_LEAN_AND_MEAN
  27 #if defined _MSC_VER
  28 #pragma warning(push, 1)
  29 #endif
  30 #include <windows.h>
  31 #include <shellapi.h>
  32 #if defined _MSC_VER
  33 #pragma warning(pop)
  34 #endif
  35
  36 #include <tchar.h>
  37
  38 #include <malloc.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <systools/win32/uwinapi.h>
  42
  43 #include <rtl/string.h>
  44 #include <sal/macros.h>
  45
  46 #include "../../../source/inc/exithelper.h"
  47 #include "../loader.hxx"
  48
  49 #include <config_version.h>
  50
  51 #define PIPE_PREFIX                 TEXT("\\\\.\\pipe\\OSL_PIPE_")
  52 #define PIPE_POSTFIX                TEXT("_SingleOfficeIPC_")
  53 #define PIPE_TERMINATION_SEQUENCE   "InternalIPC::ProcessingDone"
  54
  55 BOOL WINAPI ConvertSidToStringSid( PSID pSid, LPTSTR* StringSid )
  56 {
  57     PSID_IDENTIFIER_AUTHORITY psia;
  58     DWORD dwSubAuthorities;
  59     DWORD dwSidRev=SID_REVISION;
  60     DWORD dwCounter;
  61     DWORD dwSidSize;
  62
  63     // Validate the binary SID.
  64
  65     if(!IsValidSid(pSid)) return FALSE;
  66
  67     // Get the identifier authority value from the SID.
  68
  69     psia = GetSidIdentifierAuthority(pSid);
  70
  71     // Get the number of subauthorities in the SID.
  72
  73     dwSubAuthorities = *GetSidSubAuthorityCount(pSid);
  74
  75     // Compute the buffer length.
  76     // S-SID_REVISION- + IdentifierAuthority- + subauthorities- + NULL
  77
  78     dwSidSize=(15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR);
  79
  80     *StringSid = (LPTSTR)LocalAlloc( LMEM_FIXED, dwSidSize );
  81
  82     // Add 'S' prefix and revision number to the string.
  83
  84     dwSidSize=wsprintf(*StringSid, TEXT("S-%lu-"), dwSidRev );
  85
  86     // Add a SID identifier authority to the string.
  87
  88     if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) )
  89     {
  90         dwSidSize+=wsprintf(*StringSid + lstrlen(*StringSid),
  91                     TEXT("0x%02hx%02hx%02hx%02hx%02hx%02hx"),
  92                     (USHORT)psia->Value[0],
  93                     (USHORT)psia->Value[1],
  94                     (USHORT)psia->Value[2],
  95                     (USHORT)psia->Value[3],
  96                     (USHORT)psia->Value[4],
  97                     (USHORT)psia->Value[5]);
  98     }
  99     else
 100     {
 101         dwSidSize+=wsprintf(*StringSid + lstrlen(*StringSid),
 102                     TEXT("%lu"),
 103                     (ULONG)(psia->Value[5]      )   +
 104                     (ULONG)(psia->Value[4] <<  8)   +
 105                     (ULONG)(psia->Value[3] << 16)   +
 106                     (ULONG)(psia->Value[2] << 24)   );
 107     }
 108
 109     // Add SID subauthorities to the string.
 110     for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++)
 111     {
 112         dwSidSize+=wsprintf(*StringSid + dwSidSize, TEXT("-%lu"),
 113                     *GetSidSubAuthority(pSid, dwCounter) );
 114     }
 115
 116     return TRUE;
 117 }
 118
 119
 120
 121
 122 static LPTSTR   *GetCommandArgs( int *pArgc )
 123 {
 124 #ifdef UNICODE
 125     return CommandLineToArgvW( GetCommandLineW(), pArgc );
 126 #else
 127     *pArgc = __argc;
 128     return __argv;
 129 #endif
 130 }
 131
 132
 133
 134 namespace {
 135
 136 bool writeArgument(HANDLE pipe, char prefix, WCHAR const * argument) {
 137     CHAR szBuffer[4096];
 138     int n = WideCharToMultiByte(
 139         CP_UTF8, 0, argument, -1, szBuffer, sizeof (szBuffer), NULL, NULL);
 140     char b[1 + 2 * ((sizeof szBuffer) - 1)]; // hopefully does not overflow
 141     b[0] = prefix;
 142     char * p = b + 1;
 143     for (int i = 0; i < n - 1; ++i) { // cannot underflow (n >= 0)
 144         char c = szBuffer[i];
 145         switch (c) {
 146         case '\0':
 147             *p++ = '\\';
 148             *p++ = '0';
 149             break;
 150         case ',':
 151             *p++ = '\\';
 152             *p++ = ',';
 153             break;
 154         case '\\':
 155             *p++ = '\\';
 156             *p++ = '\\';
 157             break;
 158         default:
 159             *p++ = c;
 160             break;
 161         }
 162     }
 163     DWORD w;
 164     return WriteFile(pipe, b, p - b, &w, NULL);
 165 }
 166
 167 }
 168
 169 #ifdef __MINGW32__
 170 int WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
 171 #else
 172 int WINAPI _tWinMain( HINSTANCE, HINSTANCE, LPTSTR, int )
 173 #endif
 174 {
 175     TCHAR               szTargetFileName[MAX_PATH] = TEXT("");
 176     TCHAR               szIniDirectory[MAX_PATH];
 177     TCHAR               szPerfTuneIniFile[MAX_PATH] = TEXT("");
 178     STARTUPINFO         aStartupInfo;
 179
 180     desktop_win32::getPaths(szTargetFileName, szIniDirectory);
 181
 182     ZeroMemory( &aStartupInfo, sizeof(aStartupInfo) );
 183     aStartupInfo.cb = sizeof(aStartupInfo);
 184
 185     GetStartupInfo( &aStartupInfo );
 186     // Get image path with same name but with .bin extension
 187
 188     TCHAR               szModuleFileName[MAX_PATH];
 189
 190     GetModuleFileName( NULL, szModuleFileName, MAX_PATH );
 191     _TCHAR  *lpLastSlash = _tcsrchr( szModuleFileName, '\\' );
 192     if ( lpLastSlash )
 193     {
 194         size_t len = lpLastSlash - szModuleFileName + 1;
 195         _tcsncpy( szPerfTuneIniFile, szModuleFileName, len );
 196         _tcsncpy( szPerfTuneIniFile + len, _T("perftune.ini"), SAL_N_ELEMENTS(szPerfTuneIniFile) - len );
 197     }
 198
 199     // Create process with same command line, environment and stdio handles which
 200     // are directed to the created pipes
 201
 202     DWORD   dwExitCode = (DWORD)-1;
 203
 204     BOOL    fSuccess = FALSE;
 205     LPTSTR  lpCommandLine = NULL;
 206     int argc = 0;
 207     LPTSTR * argv = NULL;
 208     bool bFirst = true;
 209     WCHAR cwd[MAX_PATH];
 210     DWORD cwdLen = GetCurrentDirectoryW(MAX_PATH, cwd);
 211     if (cwdLen >= MAX_PATH) {
 212         cwdLen = 0;
 213     }
 214
 215     do
 216     {
 217         TCHAR   szKey[32];
 218
 219         GetPrivateProfileString(
 220             TEXT("PerformanceTuning"),
 221             TEXT("FastPipeCommunication"),
 222             TEXT("0"),
 223             szKey,
 224             SAL_N_ELEMENTS(szKey),
 225             szPerfTuneIniFile
 226             );
 227
 228         if ( 0 == _tcscmp( szKey, TEXT("1") ) )
 229         {
 230             HANDLE  hProcessToken;
 231
 232             if ( OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &hProcessToken ) )
 233             {
 234                 TCHAR   szPipeName[4096];
 235
 236
 237                 DWORD   dwTokenLength = 0;
 238
 239
 240                 fSuccess = GetTokenInformation( hProcessToken, TokenUser, NULL, dwTokenLength, &dwTokenLength );
 241
 242                 PVOID   pTokenInfo = _alloca(dwTokenLength);
 243                 fSuccess = GetTokenInformation( hProcessToken, TokenUser, pTokenInfo, dwTokenLength, &dwTokenLength );
 244                 CloseHandle( hProcessToken );
 245
 246                 PSID pSid = ((PTOKEN_USER)pTokenInfo)->User.Sid;
 247                 LPTSTR  szUserIdent = NULL;
 248                 TCHAR   szSUPD[11] = TEXT("0");
 249
 250                 fSuccess = ConvertSidToStringSid( pSid, &szUserIdent );
 251
 252                 _tcsncpy( szPipeName, PIPE_PREFIX, SAL_N_ELEMENTS(szPipeName) );
 253                 _tcsncat( szPipeName, szUserIdent, SAL_N_ELEMENTS(szPipeName) - _tcslen(szPipeName) - 1 );
 254                 _tcsncat( szPipeName, PIPE_POSTFIX, SAL_N_ELEMENTS(szPipeName) - _tcslen(szPipeName) - 1 );
 255                 _tcsncat( szPipeName, _ultot( LIBO_VERSION_MAJOR * 10000 + LIBO_VERSION_MINOR * 100 + LIBO_VERSION_MICRO * 1
 256                                             , szSUPD, 10), SAL_N_ELEMENTS(szPipeName) - _tcslen(szPipeName) - 1 );
 257
 258                 LocalFree( szUserIdent );
 259
 260                 HANDLE  hPipe = CreateFile(
 261                                     szPipeName,
 262                                     GENERIC_READ|GENERIC_WRITE,
 263                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
 264                                     NULL,
 265                                     OPEN_EXISTING,
 266                                     FILE_ATTRIBUTE_NORMAL,
 267                                     NULL);
 268
 269                 if ( INVALID_HANDLE_VALUE != hPipe )
 270                 {
 271                     DWORD   dwBytesRead = 0;
 272                     char    *pBuffer = (char *)_alloca( sizeof("InternalIPC::SendArguments") + 1);
 273                     fSuccess = ReadFile( hPipe, pBuffer, sizeof("InternalIPC::SendArguments") + 1, &dwBytesRead, NULL );
 274                     if ( fSuccess )
 275                     {
 276                         fSuccess = (dwBytesRead == (sizeof("InternalIPC::SendArguments") + 1) &&
 277                             0 == strncmp( "InternalIPC::SendArguments", pBuffer, dwBytesRead - 1 ) );
 278                     }
 279                     if ( fSuccess )
 280                     {
 281                         DWORD   dwBytesWritten;
 282                         int argc2 = 0;
 283                         LPWSTR  *argv2 = CommandLineToArgvW( GetCommandLine(), &argc2 );
 284
 285                         fSuccess = WriteFile( hPipe, RTL_CONSTASCII_STRINGPARAM("InternalIPC::Arguments"), &dwBytesWritten, NULL );
 286                         if (fSuccess) {
 287                             if (cwdLen > 0) {
 288                                 fSuccess = writeArgument(hPipe, '2', cwd);
 289                             } else {
 290                                 fSuccess = WriteFile(
 291                                     hPipe, RTL_CONSTASCII_STRINGPARAM("0"),
 292                                     &dwBytesWritten, NULL);
 293                             }
 294                         }
 295                         for ( int argn = 1; fSuccess && argn < argc2; argn++ )
 296                         {
 297                             if (std::wcsncmp(
 298                                     argv2[argn], L"-env:", std::wcslen(L"-env:"))
 299                                 != 0)
 300                             {
 301                                 fSuccess = writeArgument(hPipe, ',', argv2[argn]);
 302                             }
 303                         }
 304
 305                         if ( fSuccess )
 306                         {
 307                             fSuccess = WriteFile(  hPipe, "", 1, &dwBytesWritten, NULL );
 308                             if ( fSuccess )
 309                             {
 310                                 DWORD   dwBytesRead2 = 0;
 311                                 char    *pBuffer2 = (char *)_alloca( sizeof(PIPE_TERMINATION_SEQUENCE) );
 312                                 fSuccess = ReadFile( hPipe, pBuffer2, sizeof(PIPE_TERMINATION_SEQUENCE) - 1, &dwBytesRead2, NULL );
 313                                 if ( fSuccess )
 314                                 {
 315                                     pBuffer2[dwBytesRead2] = 0;
 316                                     if ( 0 != strcmp( PIPE_TERMINATION_SEQUENCE, pBuffer2 ) )
 317                                         fSuccess = FALSE;
 318                                 }
 319                             }
 320                         }
 321                     }
 322                     CloseHandle( hPipe );
 323
 324                     return fSuccess ? 0 : -1;
 325                 }
 326
 327             }
 328         }
 329
 330         if ( bFirst ) {
 331             argv = GetCommandArgs(&argc);
 332             std::size_t n = wcslen(argv[0]) + 2;
 333             for (int i = 1; i < argc; ++i) {
 334                 n += wcslen(argv[i]) + 3;
 335             }
 336             n += MY_LENGTH(L" \"-env:OOO_CWD=2") + 4 * cwdLen +
 337                 MY_LENGTH(L"\"") + 1;
 338                 // 4 * cwdLen: each char preceded by backslash, each trailing
 339                 // backslash doubled
 340             lpCommandLine = new WCHAR[n];
 341         }
 342         WCHAR * p = desktop_win32::commandLineAppend(
 343             lpCommandLine, MY_STRING(L"\""));
 344         p = desktop_win32::commandLineAppend(p, argv[0]);
 345         for (int i = 1; i < argc; ++i) {
 346             if (bFirst || EXITHELPER_NORMAL_RESTART == dwExitCode || wcsncmp(argv[i], MY_STRING(L"-env:")) == 0) {
 347                 p = desktop_win32::commandLineAppend(p, MY_STRING(L"\" \""));
 348                 p = desktop_win32::commandLineAppend(p, argv[i]);
 349             }
 350         }
 351
 352         p = desktop_win32::commandLineAppend(
 353             p, MY_STRING(L"\" \"-env:OOO_CWD="));
 354         if (cwdLen == 0) {
 355             p = desktop_win32::commandLineAppend(p, MY_STRING(L"0"));
 356         } else {
 357             p = desktop_win32::commandLineAppend(p, MY_STRING(L"2"));
 358             p = desktop_win32::commandLineAppendEncoded(p, cwd);
 359         }
 360         desktop_win32::commandLineAppend(p, MY_STRING(L"\""));
 361         bFirst = false;
 362
 363         TCHAR   szParentProcessId[64]; // This is more than large enough for a 128 bit decimal value
 364         BOOL    bHeadlessMode( FALSE );
 365
 366         {
 367             // Check command line arguments for "--headless" parameter. We only
 368             // set the environment variable "ATTACHED_PARENT_PROCESSID" for the headless
 369             // mode as self-destruction of the soffice.bin process can lead to
 370             // certain side-effects (log-off can result in data-loss, ".lock" is not deleted.
 371             // See 138244 for more information.
 372             int     argc2;
 373             LPTSTR  *argv2 = GetCommandArgs( &argc2 );
 374
 375             if ( argc2 > 1 )
 376             {
 377                 int n;
 378
 379                 for ( n = 1; n < argc2; n++ )
 380                 {
 381                     if ( 0 == _tcsnicmp( argv2[n], _T("-headless"), 9 ) ||
 382                          0 == _tcsnicmp( argv2[n], _T("--headless"), 10 ) )
 383                     {
 384                         bHeadlessMode = TRUE;
 385                     }
 386                 }
 387             }
 388         }
 389
 390         if ( _ltot( (long)GetCurrentProcessId(),szParentProcessId, 10 ) && bHeadlessMode )
 391             SetEnvironmentVariable( TEXT("ATTACHED_PARENT_PROCESSID"), szParentProcessId );
 392
 393         PROCESS_INFORMATION aProcessInfo;
 394
 395         fSuccess = CreateProcess(
 396             szTargetFileName,
 397             lpCommandLine,
 398             NULL,
 399             NULL,
 400             TRUE,
 401             0,
 402             NULL,
 403             szIniDirectory,
 404             &aStartupInfo,
 405             &aProcessInfo );
 406
 407         if ( fSuccess )
 408         {
 409             DWORD   dwWaitResult;
 410
 411             do
 412             {
 413                 // On Windows XP it seems as the desktop calls WaitForInputIdle after "OpenWidth" so we have to do so
 414                 // as if we where processing any messages
 415
 416                 dwWaitResult = MsgWaitForMultipleObjects( 1, &aProcessInfo.hProcess, FALSE, INFINITE, QS_ALLEVENTS );
 417
 418                 if (  WAIT_OBJECT_0 + 1 == dwWaitResult )
 419                 {
 420                     MSG msg;
 421
 422                     PeekMessage( &msg, NULL, 0, 0, PM_REMOVE );
 423                 }
 424             } while ( WAIT_OBJECT_0 + 1 == dwWaitResult );
 425
 426             dwExitCode = 0;
 427             GetExitCodeProcess( aProcessInfo.hProcess, &dwExitCode );
 428
 429             CloseHandle( aProcessInfo.hProcess );
 430             CloseHandle( aProcessInfo.hThread );
 431         }
 432     } while ( fSuccess
 433               && ( EXITHELPER_CRASH_WITH_RESTART == dwExitCode || EXITHELPER_NORMAL_RESTART == dwExitCode ));
 434     delete[] lpCommandLine;
 435
 436     return fSuccess ? dwExitCode : -1;
 437 }
 438
 439 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */