sal/osl/w32/dllentry.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 #include <systools/win32/uwinapi.h>
  21 #include <tlhelp32.h>
  22 #include <rpc.h>
  23 #include <winsock.h>
  24 #ifdef _DEBUG
  25 #include <crtdbg.h>
  26 #endif
  27 #include <osl/diagnose.h>
  28 #include <sal/types.h>
  29 #include <float.h>
  30
  31 #include <osl/mutex.h>
  32 #include <osl/thread.h>
  33
  34 #include "file_url.hxx"
  35 #include <rtllifecycle.h>
  36
  37 #include "thread.hxx"
  38
  39 /*
  40 This is needed because DllMain is called after static constructors. A DLL's
  41 startup and shutdown sequence looks like this:
  42
  43 _pRawDllMain()
  44 _CRT_INIT()
  45 DllMain()
  46 ...
  47 DllMain()
  48 _CRT_INIT()
  49 _pRawDllMain()
  50
  51 */
  52
  53 extern "C" {
  54
  55 static BOOL WINAPI RawDllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved );
  56 BOOL (WINAPI *_pRawDllMain)(HINSTANCE, DWORD, LPVOID) = RawDllMain;
  57
  58 }
  59
  60 static BOOL WINAPI RawDllMain( HINSTANCE, DWORD fdwReason, LPVOID )
  61 {
  62     switch (fdwReason)
  63     {
  64         case DLL_PROCESS_ATTACH:
  65             {
  66 #ifdef _DEBUG
  67                 WCHAR buf[64];
  68                 DWORD const res = GetEnvironmentVariableW(L"SAL_NO_ASSERT_DIALOGS", buf, SAL_N_ELEMENTS(buf));
  69                 if (res && res < SAL_N_ELEMENTS(buf))
  70                 {
  71                     // disable the dialog on abort()
  72                     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
  73                     _CrtSetReportMode(_CRT_ERROR, (_CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE));
  74                     // not sure which assertions this affects
  75                     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
  76                     _CrtSetReportMode(_CRT_ASSERT, (_CRTDBG_MODE_DEBUG|_CRTDBG_MODE_FILE));
  77                     // disable the dialog on assert(false)
  78                     _set_error_mode(_OUT_TO_STDERR);
  79                 }
  80 #endif
  81
  82 #if OSL_DEBUG_LEVEL < 2
  83                 /* Suppress file error messages from system like "Floppy A: not inserted" */
  84                 SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS );
  85 #endif
  86
  87                 //We disable floating point exceptions. This is the usual state at program startup
  88                 //but on Windows 98 and ME this is not always the case.
  89                 _control87(_MCW_EM, _MCW_EM);
  90                 break;
  91             }
  92
  93         case DLL_PROCESS_DETACH:
  94             WSACleanup( );
  95
  96             /*
  97
  98             On a product build memory management finalization might
  99             cause a crash without assertion (assertions off) if heap is
 100             corrupted. But a crash report won't help here because at
 101             this point all other threads have been terminated and only
 102             ntdll is on the stack. No chance to find the reason for the
 103             corrupted heap if so.
 104
 105             So annoying the user with a crash report is completely useless.
 106
 107             */
 108
 109 #ifndef DBG_UTIL
 110             __try
 111 #endif
 112             {
 113                 /* cleanup locale hashtable */
 114                 rtl_locale_fini();
 115
 116                 /* finalize memory management */
 117                 rtl_cache_fini();
 118                 rtl_arena_fini();
 119             }
 120 #ifndef DBG_UTIL
 121             __except( EXCEPTION_EXECUTE_HANDLER )
 122             {
 123             }
 124 #endif
 125             break;
 126     }
 127
 128     return TRUE;
 129 }
 130
 131 static DWORD GetParentProcessId()
 132 {
 133     DWORD   dwParentProcessId = 0;
 134     HANDLE  hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
 135
 136     if ( IsValidHandle( hSnapshot ) )
 137     {
 138         PROCESSENTRY32  pe;
 139         bool            fSuccess;
 140
 141         ZeroMemory( &pe, sizeof(pe) );
 142         pe.dwSize = sizeof(pe);
 143         fSuccess = Process32First( hSnapshot, &pe );
 144
 145         while( fSuccess )
 146         {
 147             if ( GetCurrentProcessId() == pe.th32ProcessID )
 148             {
 149                 dwParentProcessId = pe.th32ParentProcessID;
 150                 break;
 151             }
 152
 153             fSuccess = Process32Next( hSnapshot, &pe );
 154         }
 155
 156         CloseHandle( hSnapshot );
 157     }
 158
 159     return dwParentProcessId;
 160 }
 161
 162 static DWORD WINAPI ParentMonitorThreadProc( LPVOID lpParam )
 163 {
 164     DWORD_PTR dwParentProcessId = reinterpret_cast<DWORD_PTR>(lpParam);
 165
 166     HANDLE  hParentProcess = OpenProcess( SYNCHRONIZE, FALSE, dwParentProcessId );
 167
 168     osl_setThreadName("headless ParentMonitorThread");
 169
 170     if ( IsValidHandle( hParentProcess ) )
 171     {
 172         if ( WAIT_OBJECT_0 == WaitForSingleObject( hParentProcess, INFINITE ) )
 173         {
 174             TerminateProcess( GetCurrentProcess(), 0 );
 175         }
 176         CloseHandle( hParentProcess );
 177     }
 178     return 0;
 179 }
 180
 181 extern "C"
 182 BOOL WINAPI DllMain( HINSTANCE, DWORD fdwReason, LPVOID )
 183 {
 184     switch (fdwReason)
 185     {
 186         case DLL_PROCESS_ATTACH:
 187         {
 188             WCHAR szBuffer[64];
 189
 190             // This code will attach the process to its parent process
 191             // if the parent process had set the environment variable.
 192             // The corresponding code (setting the environment variable)
 193             // is desktop/win32/source/officeloader.cxx
 194
 195             DWORD dwResult = GetEnvironmentVariableW( L"ATTACHED_PARENT_PROCESSID", szBuffer, SAL_N_ELEMENTS(szBuffer) );
 196
 197             if ( dwResult && dwResult < SAL_N_ELEMENTS(szBuffer) )
 198             {
 199                 DWORD   dwThreadId = 0;
 200
 201                 DWORD_PTR dwParentProcessId = static_cast<DWORD_PTR>(_wtol( szBuffer ));
 202
 203                 if ( dwParentProcessId && GetParentProcessId() == dwParentProcessId )
 204                 {
 205                     // No error check, it works or it does not
 206                     // Thread should only be started for headless mode, see desktop/win32/source/officeloader.cxx
 207                     HANDLE hThread
 208                         = CreateThread(nullptr, 0, ParentMonitorThreadProc,
 209                                        reinterpret_cast<LPVOID>(dwParentProcessId), 0, &dwThreadId);
 210                     // Note: calling CreateThread in DllMain is discouraged
 211                     // but this is only done in the headless mode and in
 212                     // that case no other threads should be running at startup
 213                     // when sal3.dll is loaded; also there is no
 214                     // synchronization with the spawned thread, so there
 215                     // does not appear to be a real risk of deadlock here
 216                     if (hThread)
 217                         CloseHandle(hThread);
 218                 }
 219             }
 220
 221             return TRUE;
 222         }
 223
 224         case DLL_THREAD_ATTACH:
 225             break;
 226
 227         case DLL_THREAD_DETACH:
 228             osl_callThreadKeyCallbackOnThreadDetach( );
 229             break;
 230     }
 231
 232     return TRUE;
 233 }
 234
 235 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */