| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_desktop.hxx" |
| #define UNICODE |
| #define _UNICODE |
| |
| #include <cstddef> |
| |
| #define WIN32_LEAN_AND_MEAN |
| #if defined _MSC_VER |
| #pragma warning(push, 1) |
| #endif |
| #include <windows.h> |
| #include <shellapi.h> |
| #if defined _MSC_VER |
| #pragma warning(pop) |
| #endif |
| |
| #include <tchar.h> |
| |
| #include <malloc.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <systools/win32/uwinapi.h> |
| |
| #include "rtl/string.h" |
| |
| #include "../../../source/inc/exithelper.hxx" |
| #include "../extendloaderenvironment.hxx" |
| |
| #define PIPE_PREFIX TEXT("\\\\.\\pipe\\OSL_PIPE_") |
| #define PIPE_POSTFIX TEXT("_SingleOfficeIPC_") |
| #define PIPE_TERMINATION_SEQUENCE "InternalIPC::ProcessingDone" |
| |
| BOOL WINAPI ConvertSidToStringSid( PSID pSid, LPTSTR* StringSid ) |
| { |
| PSID_IDENTIFIER_AUTHORITY psia; |
| DWORD dwSubAuthorities; |
| DWORD dwSidRev=SID_REVISION; |
| DWORD dwCounter; |
| DWORD dwSidSize; |
| |
| // Validate the binary SID. |
| |
| if(!IsValidSid(pSid)) return FALSE; |
| |
| // Get the identifier authority value from the SID. |
| |
| psia = GetSidIdentifierAuthority(pSid); |
| |
| // Get the number of subauthorities in the SID. |
| |
| dwSubAuthorities = *GetSidSubAuthorityCount(pSid); |
| |
| // Compute the buffer length. |
| // S-SID_REVISION- + IdentifierAuthority- + subauthorities- + NULL |
| |
| dwSidSize=(15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR); |
| |
| *StringSid = (LPTSTR)LocalAlloc( LMEM_FIXED, dwSidSize ); |
| |
| // Add 'S' prefix and revision number to the string. |
| |
| dwSidSize=wsprintf(*StringSid, TEXT("S-%lu-"), dwSidRev ); |
| |
| // Add a SID identifier authority to the string. |
| |
| if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) ) |
| { |
| dwSidSize+=wsprintf(*StringSid + lstrlen(*StringSid), |
| TEXT("0x%02hx%02hx%02hx%02hx%02hx%02hx"), |
| (USHORT)psia->Value[0], |
| (USHORT)psia->Value[1], |
| (USHORT)psia->Value[2], |
| (USHORT)psia->Value[3], |
| (USHORT)psia->Value[4], |
| (USHORT)psia->Value[5]); |
| } |
| else |
| { |
| dwSidSize+=wsprintf(*StringSid + lstrlen(*StringSid), |
| TEXT("%lu"), |
| (ULONG)(psia->Value[5] ) + |
| (ULONG)(psia->Value[4] << 8) + |
| (ULONG)(psia->Value[3] << 16) + |
| (ULONG)(psia->Value[2] << 24) ); |
| } |
| |
| // Add SID subauthorities to the string. |
| // |
| for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++) |
| { |
| dwSidSize+=wsprintf(*StringSid + dwSidSize, TEXT("-%lu"), |
| *GetSidSubAuthority(pSid, dwCounter) ); |
| } |
| |
| return TRUE; |
| } |
| |
| |
| //--------------------------------------------------------------------------- |
| |
| static LPTSTR *GetCommandArgs( int *pArgc ) |
| { |
| #ifdef UNICODE |
| return CommandLineToArgvW( GetCommandLineW(), pArgc ); |
| #else |
| *pArgc = __argc; |
| return __argv; |
| #endif |
| } |
| |
| //--------------------------------------------------------------------------- |
| |
| namespace { |
| |
| bool writeArgument(HANDLE pipe, char prefix, WCHAR const * argument) { |
| CHAR szBuffer[4096]; |
| int n = WideCharToMultiByte( |
| CP_UTF8, 0, argument, -1, szBuffer, sizeof (szBuffer), NULL, NULL); |
| char b[1 + 2 * ((sizeof szBuffer) - 1)]; // hopefully does not overflow |
| b[0] = prefix; |
| char * p = b + 1; |
| for (int i = 0; i < n - 1; ++i) { // cannot underflow (n >= 0) |
| char c = szBuffer[i]; |
| switch (c) { |
| case '\0': |
| *p++ = '\\'; |
| *p++ = '0'; |
| break; |
| case ',': |
| *p++ = '\\'; |
| *p++ = ','; |
| break; |
| case '\\': |
| *p++ = '\\'; |
| *p++ = '\\'; |
| break; |
| default: |
| *p++ = c; |
| break; |
| } |
| } |
| DWORD w; |
| return WriteFile(pipe, b, p - b, &w, NULL); |
| } |
| |
| } |
| |
| #ifdef __MINGW32__ |
| int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE, LPSTR, int ) |
| #else |
| int WINAPI _tWinMain( HINSTANCE, HINSTANCE, LPTSTR, int ) |
| #endif |
| { |
| TCHAR szTargetFileName[MAX_PATH] = TEXT(""); |
| TCHAR szIniDirectory[MAX_PATH]; |
| TCHAR szPerfTuneIniFile[MAX_PATH] = TEXT(""); |
| STARTUPINFO aStartupInfo; |
| |
| desktop_win32::extendLoaderEnvironment(szTargetFileName, szIniDirectory); |
| |
| ZeroMemory( &aStartupInfo, sizeof(aStartupInfo) ); |
| aStartupInfo.cb = sizeof(aStartupInfo); |
| |
| GetStartupInfo( &aStartupInfo ); |
| // Get image path with same name but with .bin extension |
| |
| TCHAR szModuleFileName[MAX_PATH]; |
| |
| GetModuleFileName( NULL, szModuleFileName, MAX_PATH ); |
| _TCHAR *lpLastSlash = _tcsrchr( szModuleFileName, '\\' ); |
| if ( lpLastSlash ) |
| { |
| size_t len = lpLastSlash - szModuleFileName + 1; |
| _tcsncpy( szPerfTuneIniFile, szModuleFileName, len ); |
| _tcsncpy( szPerfTuneIniFile + len, _T("perftune.ini"), sizeof(szPerfTuneIniFile)/sizeof(szPerfTuneIniFile[0]) - len ); |
| } |
| |
| // Create process with same command line, environment and stdio handles which |
| // are directed to the created pipes |
| |
| DWORD dwExitCode = (DWORD)-1; |
| |
| BOOL fSuccess = FALSE; |
| LPTSTR lpCommandLine = NULL; |
| int argc = 0; |
| LPTSTR * argv = NULL; |
| bool bFirst = true; |
| WCHAR cwd[MAX_PATH]; |
| DWORD cwdLen = GetCurrentDirectoryW(MAX_PATH, cwd); |
| if (cwdLen >= MAX_PATH) { |
| cwdLen = 0; |
| } |
| |
| do |
| { |
| TCHAR szKey[32]; |
| |
| GetPrivateProfileString( |
| TEXT("PerformanceTuning"), |
| TEXT("FastPipeCommunication"), |
| TEXT("0"), |
| szKey, |
| elementsof(szKey), |
| szPerfTuneIniFile |
| ); |
| |
| if ( 0 == _tcscmp( szKey, TEXT("1") ) ) |
| { |
| HANDLE hProcessToken; |
| |
| if ( OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &hProcessToken ) ) |
| { |
| TCHAR szPipeName[4096]; |
| |
| |
| DWORD dwTokenLength = 0; |
| |
| |
| fSuccess = GetTokenInformation( hProcessToken, TokenUser, NULL, dwTokenLength, &dwTokenLength ); |
| |
| PVOID pTokenInfo = _alloca(dwTokenLength); |
| fSuccess = GetTokenInformation( hProcessToken, TokenUser, pTokenInfo, dwTokenLength, &dwTokenLength ); |
| CloseHandle( hProcessToken ); |
| |
| PSID pSid = ((PTOKEN_USER)pTokenInfo)->User.Sid; |
| LPTSTR szUserIdent = NULL; |
| TCHAR szSUPD[11] = TEXT("0"); |
| |
| fSuccess = ConvertSidToStringSid( pSid, &szUserIdent ); |
| |
| _tcsncpy( szPipeName, PIPE_PREFIX, elementsof(szPipeName) ); |
| _tcsncat( szPipeName, szUserIdent, elementsof(szPipeName) - _tcslen(szPipeName) - 1 ); |
| _tcsncat( szPipeName, PIPE_POSTFIX, elementsof(szPipeName) - _tcslen(szPipeName) - 1 ); |
| _tcsncat( szPipeName, _ultot( SUPD, szSUPD, 10), elementsof(szPipeName) - _tcslen(szPipeName) - 1 ); |
| |
| LocalFree( szUserIdent ); |
| |
| HANDLE hPipe = CreateFile( |
| szPipeName, |
| GENERIC_READ|GENERIC_WRITE, |
| FILE_SHARE_READ | FILE_SHARE_WRITE, |
| NULL, |
| OPEN_EXISTING, |
| FILE_ATTRIBUTE_NORMAL, |
| NULL); |
| |
| if ( INVALID_HANDLE_VALUE != hPipe ) |
| { |
| DWORD dwBytesWritten; |
| int argc = 0; |
| LPWSTR *argv = CommandLineToArgvW( GetCommandLine(), &argc ); |
| |
| fSuccess = WriteFile( hPipe, RTL_CONSTASCII_STRINGPARAM("InternalIPC::Arguments"), &dwBytesWritten, NULL ); |
| if (fSuccess) { |
| if (cwdLen > 0) { |
| fSuccess = writeArgument(hPipe, '2', cwd); |
| } else { |
| fSuccess = WriteFile( |
| hPipe, RTL_CONSTASCII_STRINGPARAM("0"), |
| &dwBytesWritten, NULL); |
| } |
| } |
| for ( int argn = 1; fSuccess && argn < argc; argn++ ) |
| { |
| fSuccess = writeArgument(hPipe, ',', argv[argn]); |
| } |
| |
| if ( fSuccess ) |
| { |
| fSuccess = WriteFile( hPipe, "", 1, &dwBytesWritten, NULL ); |
| if ( fSuccess ) |
| { |
| DWORD dwBytesRead = 0; |
| char *pBuffer = (char *)_alloca( sizeof(PIPE_TERMINATION_SEQUENCE) ); |
| fSuccess = ReadFile( hPipe, pBuffer, sizeof(PIPE_TERMINATION_SEQUENCE) - 1, &dwBytesRead, NULL ); |
| if ( fSuccess ) |
| { |
| pBuffer[dwBytesRead] = 0; |
| if ( 0 != strcmp( PIPE_TERMINATION_SEQUENCE, pBuffer ) ) |
| fSuccess = FALSE; |
| } |
| } |
| } |
| |
| CloseHandle( hPipe ); |
| |
| return fSuccess ? 0 : -1; |
| } |
| |
| } |
| } |
| |
| if ( bFirst ) { |
| argv = GetCommandArgs(&argc); |
| std::size_t n = wcslen(argv[0]) + 2; |
| for (int i = 1; i < argc; ++i) { |
| n += wcslen(argv[i]) + 3; |
| } |
| n += MY_LENGTH(L" \"-env:OOO_CWD=2") + 4 * cwdLen + |
| MY_LENGTH(L"\"") + 1; |
| // 4 * cwdLen: each char preceded by backslash, each trailing |
| // backslash doubled |
| lpCommandLine = new WCHAR[n]; |
| } |
| WCHAR * p = desktop_win32::commandLineAppend( |
| lpCommandLine, MY_STRING(L"\"")); |
| p = desktop_win32::commandLineAppend(p, argv[0]); |
| for (int i = 1; i < argc; ++i) { |
| if (bFirst || ::desktop::ExitHelper::E_NORMAL_RESTART == dwExitCode || wcsncmp(argv[i], MY_STRING(L"-env:")) == 0) { |
| p = desktop_win32::commandLineAppend(p, MY_STRING(L"\" \"")); |
| p = desktop_win32::commandLineAppend(p, argv[i]); |
| } |
| } |
| |
| p = desktop_win32::commandLineAppend( |
| p, MY_STRING(L"\" \"-env:OOO_CWD=")); |
| if (cwdLen == 0) { |
| p = desktop_win32::commandLineAppend(p, MY_STRING(L"0")); |
| } else { |
| p = desktop_win32::commandLineAppend(p, MY_STRING(L"2")); |
| p = desktop_win32::commandLineAppendEncoded(p, cwd); |
| } |
| desktop_win32::commandLineAppend(p, MY_STRING(L"\"")); |
| bFirst = false; |
| |
| TCHAR szParentProcessId[64]; // This is more than large enough for a 128 bit decimal value |
| BOOL bHeadlessMode( FALSE ); |
| |
| { |
| // Check command line arguments for "-headless" parameter. We only |
| // set the environment variable "ATTACHED_PARENT_PROCESSID" for the headless |
| // mode as self-destruction of the soffice.bin process can lead to |
| // certain side-effects (log-off can result in data-loss, ".lock" is not deleted. |
| // See 138244 for more information. |
| int argc; |
| LPTSTR *argv = GetCommandArgs( &argc ); |
| |
| if ( argc > 1 ) |
| { |
| int n; |
| |
| for ( n = 1; n < argc; n++ ) |
| { |
| if ( 0 == _tcsnicmp( argv[n], _T("-headless"), 9 ) ) |
| bHeadlessMode = TRUE; |
| } |
| } |
| } |
| |
| if ( _ltot( (long)GetCurrentProcessId(),szParentProcessId, 10 ) && bHeadlessMode ) |
| SetEnvironmentVariable( TEXT("ATTACHED_PARENT_PROCESSID"), szParentProcessId ); |
| |
| PROCESS_INFORMATION aProcessInfo; |
| |
| fSuccess = CreateProcess( |
| szTargetFileName, |
| lpCommandLine, |
| NULL, |
| NULL, |
| TRUE, |
| 0, |
| NULL, |
| szIniDirectory, |
| &aStartupInfo, |
| &aProcessInfo ); |
| |
| if ( fSuccess ) |
| { |
| DWORD dwWaitResult; |
| |
| do |
| { |
| // On Windows XP it seems as the desktop calls WaitForInputIdle after "OpenWidth" so we have to do so |
| // as if we where processing any messages |
| |
| dwWaitResult = MsgWaitForMultipleObjects( 1, &aProcessInfo.hProcess, FALSE, INFINITE, QS_ALLEVENTS ); |
| |
| if ( WAIT_OBJECT_0 + 1 == dwWaitResult ) |
| { |
| MSG msg; |
| |
| PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ); |
| } |
| } while ( WAIT_OBJECT_0 + 1 == dwWaitResult ); |
| |
| dwExitCode = 0; |
| GetExitCodeProcess( aProcessInfo.hProcess, &dwExitCode ); |
| |
| CloseHandle( aProcessInfo.hProcess ); |
| CloseHandle( aProcessInfo.hThread ); |
| } |
| } while ( fSuccess |
| && ( ::desktop::ExitHelper::E_CRASH_WITH_RESTART == dwExitCode || ::desktop::ExitHelper::E_NORMAL_RESTART == dwExitCode )); |
| delete[] lpCommandLine; |
| |
| return fSuccess ? dwExitCode : -1; |
| } |
