sal/osl/w32/dllentry.c

   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 #ifdef _MSC_VER
  21 #pragma warning(push,1) /* disable warnings within system headers */
  22 #endif
  23 #include <windows.h>
  24 #ifdef _MSC_VER
  25 #pragma warning(pop)
  26 #endif
  27 #include <tlhelp32.h>
  28 #include <systools/win32/uwinapi.h>
  29 #include <winsock.h>
  30 #include <osl/diagnose.h>
  31 #include <sal/types.h>
  32 #include <float.h>
  33
  34 #include <osl/diagnose.h>
  35 #include <osl/mutex.h>
  36 #include <sal/types.h>
  37
  38 #include "internal/rtllifecycle.h"
  39
  40 //------------------------------------------------------------------------------
  41 // externals
  42 //------------------------------------------------------------------------------
  43
  44 extern DWORD            g_dwTLSTextEncodingIndex;
  45 extern void SAL_CALL    _osl_callThreadKeyCallbackOnThreadDetach(void);
  46 extern CRITICAL_SECTION g_ThreadKeyListCS;
  47 extern oslMutex         g_Mutex;
  48 extern oslMutex         g_CurrentDirectoryMutex;
  49
  50 #ifdef __MINGW32__
  51
  52 typedef void (*func_ptr) (void);
  53 extern func_ptr __CTOR_LIST__[];
  54 extern func_ptr __DTOR_LIST__[];
  55
  56 static void do_startup(void);
  57 static void do_cleanup(void);
  58
  59 #else
  60
  61 /*
  62 This is needed because DllMain is called after static constructors. A DLL's
  63 startup and shutdown sequence looks like this:
  64
  65 _pRawDllMain()
  66 _CRT_INIT()
  67 DllMain()
  68 ....
  69 DllMain()
  70 _CRT_INIT()
  71 _pRawDllMain()
  72
  73 */
  74
  75 static BOOL WINAPI _RawDllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved );
  76 extern BOOL (WINAPI *_pRawDllMain)(HANDLE, DWORD, LPVOID) = _RawDllMain;
  77
  78 #endif
  79
  80 #ifdef __MINGW32__
  81
  82 void
  83 __do_global_dtors (void)
  84 {
  85   static func_ptr *p = __DTOR_LIST__ + 1;
  86
  87   /*
  88    * Call each destructor in the destructor list until a null pointer
  89    * is encountered.
  90    */
  91   while (*p)
  92     {
  93       (*(p)) ();
  94       p++;
  95     }
  96 }
  97
  98 void
  99 __do_global_ctors (void)
 100 {
 101   sal_uIntPtr nptrs = (sal_uIntPtr) __CTOR_LIST__[0];
 102   unsigned i;
 103
 104   /*
 105    * If the first entry in the constructor list is -1 then the list
 106    * is terminated with a null entry. Otherwise the first entry was
 107    * the number of pointers in the list.
 108    */
 109   if (nptrs == (sal_uIntPtr)-1)
 110     {
 111       for (nptrs = 0; __CTOR_LIST__[nptrs + 1] != 0; nptrs++)
 112     ;
 113     }
 114
 115   /*
 116    * Go through the list backwards calling constructors.
 117    */
 118   for (i = nptrs; i >= 1; i--)
 119     {
 120       __CTOR_LIST__[i] ();
 121     }
 122
 123   /*
 124    * Register the destructors for processing on exit.
 125    */
 126   atexit (__do_global_dtors);
 127 }
 128
 129 static int initialized = 0;
 130
 131 void
 132 __main (void)
 133 {
 134   if (!initialized)
 135     {
 136       initialized = 1;
 137       do_startup();
 138       __do_global_ctors ();
 139     }
 140 }
 141
 142 static void do_startup( void )
 143 {
 144 #else
 145 static BOOL WINAPI _RawDllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
 146 {
 147     (void)hinstDLL; /* avoid warnings */
 148     (void)lpvReserved; /* avoid warnings */
 149
 150     switch (fdwReason)
 151     {
 152         case DLL_PROCESS_ATTACH:
 153             {
 154 #endif
 155
 156 #if OSL_DEBUG_LEVEL < 2
 157                 /* Suppress file error messages from system like "Floppy A: not inserted" */
 158                 SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS );
 159 #endif
 160
 161                 /* initialize global mutex */
 162                 g_Mutex = osl_createMutex();
 163
 164                 /* initialize "current directory" mutex */
 165                 g_CurrentDirectoryMutex = osl_createMutex();
 166
 167                 g_dwTLSTextEncodingIndex = TlsAlloc();
 168                 InitializeCriticalSection( &g_ThreadKeyListCS );
 169
 170                 //We disable floating point exceptions. This is the usual state at program startup
 171                 //but on Windows 98 and ME this is not always the case.
 172                 _control87(_MCW_EM, _MCW_EM);
 173 #ifdef __MINGW32__
 174         atexit(do_cleanup);
 175 }
 176
 177 void do_cleanup( void )
 178 {
 179 #else
 180                 break;
 181             }
 182
 183         case DLL_PROCESS_DETACH:
 184 #endif
 185
 186             WSACleanup( );
 187
 188             TlsFree( g_dwTLSTextEncodingIndex );
 189             DeleteCriticalSection( &g_ThreadKeyListCS );
 190
 191             osl_destroyMutex( g_Mutex );
 192
 193             osl_destroyMutex( g_CurrentDirectoryMutex );
 194
 195 #ifndef __MINGW32__
 196
 197             /*
 198
 199             On a product build memory management finalization might
 200             cause a crash without assertion (assertions off) if heap is
 201             corrupted. But a crash report won't help here because at
 202             this point all other threads have been terminated and only
 203             ntdll is on the stack. No chance to find the reason for the
 204             corrupted heap if so.
 205
 206             So annoying the user with a crash report is completely useless.
 207
 208             */
 209
 210 #ifndef DBG_UTIL
 211             __try
 212 #endif
 213             {
 214                 /* cleanup locale hashtable */
 215                 rtl_locale_fini();
 216
 217                 /* finalize memory management */
 218                 rtl_memory_fini();
 219                 rtl_cache_fini();
 220                 rtl_arena_fini();
 221             }
 222 #ifndef DBG_UTIL
 223             __except( EXCEPTION_EXECUTE_HANDLER )
 224             {
 225             }
 226 #endif
 227             break;
 228     }
 229
 230     return TRUE;
 231 #endif
 232 }
 233
 234 static DWORD GetParentProcessId()
 235 {
 236     DWORD   dwParentProcessId = 0;
 237     HANDLE  hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );
 238
 239     if ( IsValidHandle( hSnapshot ) )
 240     {
 241         PROCESSENTRY32  pe;
 242         BOOL            fSuccess;
 243
 244         ZeroMemory( &pe, sizeof(pe) );
 245         pe.dwSize = sizeof(pe);
 246         fSuccess = Process32First( hSnapshot, &pe );
 247
 248         while( fSuccess )
 249         {
 250             if ( GetCurrentProcessId() == pe.th32ProcessID )
 251             {
 252                 dwParentProcessId = pe.th32ParentProcessID;
 253                 break;
 254             }
 255
 256             fSuccess = Process32Next( hSnapshot, &pe );
 257         }
 258
 259         CloseHandle( hSnapshot );
 260     }
 261
 262     return dwParentProcessId;
 263 }
 264
 265 static DWORD WINAPI ParentMonitorThreadProc( LPVOID lpParam )
 266 {
 267     DWORD_PTR dwParentProcessId = (DWORD_PTR)lpParam;
 268
 269     HANDLE  hParentProcess = OpenProcess( SYNCHRONIZE, FALSE, dwParentProcessId );
 270     if ( IsValidHandle( hParentProcess ) )
 271     {
 272         if ( WAIT_OBJECT_0 == WaitForSingleObject( hParentProcess, INFINITE ) )
 273         {
 274             TerminateProcess( GetCurrentProcess(), 0 );
 275         }
 276         CloseHandle( hParentProcess );
 277     }
 278     return 0;
 279 }
 280
 281 BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
 282 {
 283     (void)hinstDLL; /* avoid warning */
 284     (void)lpvReserved; /* avoid warning */
 285     switch (fdwReason)
 286     {
 287         case DLL_PROCESS_ATTACH:
 288         {
 289             TCHAR   szBuffer[64];
 290
 291             // This code will attach the process to it's parent process
 292             // if the parent process had set the environment variable.
 293             // The corresponding code (setting the environment variable)
 294             // is is desktop/win32/source/officeloader.cxx
 295
 296
 297             DWORD   dwResult = GetEnvironmentVariable( "ATTACHED_PARENT_PROCESSID", szBuffer, sizeof(szBuffer) );
 298
 299             if ( dwResult && dwResult < sizeof(szBuffer) )
 300             {
 301                 DWORD   dwThreadId = 0;
 302
 303                 DWORD_PTR   dwParentProcessId = (DWORD_PTR)atol( szBuffer );
 304
 305                 if ( dwParentProcessId && GetParentProcessId() == dwParentProcessId )
 306                 {
 307                     // No error check, it works or it does not
 308                     // Thread should only be started for headless mode, see desktop/win32/source/officeloader.cxx
 309                     CreateThread( NULL, 0, ParentMonitorThreadProc, (LPVOID)dwParentProcessId, 0, &dwThreadId ); //
 310                 }
 311             }
 312
 313             return TRUE;
 314         }
 315
 316         case DLL_THREAD_ATTACH:
 317             break;
 318
 319         case DLL_THREAD_DETACH:
 320             _osl_callThreadKeyCallbackOnThreadDetach( );
 321             break;
 322     }
 323
 324     return TRUE;
 325 }
 326
 327 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */