src/OSSupport_Win32.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2014 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Lesser General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2.1 of the License, or (at your option) any later version.
   9 //
  10 // This library is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 // Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19 // http://www.gnu.org/licenses/lgpl-2.1.txt
  20 //////////////////////////////////////////////////////////////////////////////////
  21
  22 #pragma once
  23
  24 //Internal
  25 #include <MUtils/Global.h>
  26 #include <MUtils/OSSupport.h>
  27 #include "CriticalSection_Win32.h"
  28
  29 //Win32 API
  30 #define WIN32_LEAN_AND_MEAN 1
  31 #include <Windows.h>
  32 #include <Objbase.h>
  33 #include <Psapi.h>
  34
  35 //Qt
  36 #include <QMap>
  37 #include <QReadWriteLock>
  38 #include <QLibrary>
  39 #include <QDir>
  40
  41 //Main thread ID
  42 static const DWORD g_main_thread_id = GetCurrentThreadId();
  43
  44 ///////////////////////////////////////////////////////////////////////////////
  45 // KNWON FOLDERS
  46 ///////////////////////////////////////////////////////////////////////////////
  47
  48 typedef HRESULT (WINAPI *SHGetKnownFolderPath_t)(const GUID &rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
  49 typedef HRESULT (WINAPI *SHGetFolderPath_t)(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
  50
  51 static QMap<size_t, QString>* g_known_folders_map;
  52 static SHGetKnownFolderPath_t g_known_folders_fpGetKnownFolderPath;
  53 static SHGetFolderPath_t      g_known_folders_fpGetFolderPath;
  54 static QReadWriteLock         g_known_folders_lock;
  55
  56 const QString &MUtils::OS::known_folder(known_folder_t folder_id)
  57 {
  58         static const int CSIDL_FLAG_CREATE = 0x8000;
  59         typedef enum { KF_FLAG_CREATE = 0x00008000 } kf_flags_t;
  60
  61         struct
  62         {
  63                 const int csidl;
  64                 const GUID guid;
  65         }
  66         static s_folders[] =
  67         {
  68                 { 0x001c, {0xF1B32785,0x6FBA,0x4FCF,{0x9D,0x55,0x7B,0x8E,0x7F,0x15,0x70,0x91}} },  //CSIDL_LOCAL_APPDATA
  69                 { 0x0026, {0x905e63b6,0xc1bf,0x494e,{0xb2,0x9c,0x65,0xb7,0x32,0xd3,0xd2,0x1a}} },  //CSIDL_PROGRAM_FILES
  70                 { 0x0024, {0xF38BF404,0x1D43,0x42F2,{0x93,0x05,0x67,0xDE,0x0B,0x28,0xFC,0x23}} },  //CSIDL_WINDOWS_FOLDER
  71                 { 0x0025, {0x1AC14E77,0x02E7,0x4E5D,{0xB7,0x44,0x2E,0xB1,0xAE,0x51,0x98,0xB7}} },  //CSIDL_SYSTEM_FOLDER
  72         };
  73
  74         size_t folderId = size_t(-1);
  75
  76         switch(folder_id)
  77         {
  78                 case FOLDER_LOCALAPPDATA: folderId = 0; break;
  79                 case FOLDER_PROGRAMFILES: folderId = 1; break;
  80                 case FOLDER_SYSTROOT_DIR: folderId = 2; break;
  81                 case FOLDER_SYSTEMFOLDER: folderId = 3; break;
  82         }
  83
  84         if(folderId == size_t(-1))
  85         {
  86                 qWarning("Invalid 'known' folder was requested!");
  87                 return *reinterpret_cast<QString*>(NULL);
  88         }
  89
  90         QReadLocker readLock(&g_known_folders_lock);
  91
  92         //Already in cache?
  93         if(g_known_folders_map)
  94         {
  95                 if(g_known_folders_map->contains(folderId))
  96                 {
  97                         return g_known_folders_map->operator[](folderId);
  98                 }
  99         }
 100
 101         //Obtain write lock to initialize
 102         readLock.unlock();
 103         QWriteLocker writeLock(&g_known_folders_lock);
 104
 105         //Still not in cache?
 106         if(g_known_folders_map)
 107         {
 108                 if(g_known_folders_map->contains(folderId))
 109                 {
 110                         return g_known_folders_map->operator[](folderId);
 111                 }
 112         }
 113
 114         //Initialize on first call
 115         if(!g_known_folders_map)
 116         {
 117                 QLibrary shell32("shell32.dll");
 118                 if(shell32.load())
 119                 {
 120                         g_known_folders_fpGetFolderPath =      (SHGetFolderPath_t)      shell32.resolve("SHGetFolderPathW");
 121                         g_known_folders_fpGetKnownFolderPath = (SHGetKnownFolderPath_t) shell32.resolve("SHGetKnownFolderPath");
 122                 }
 123                 g_known_folders_map = new QMap<size_t, QString>();
 124         }
 125
 126         QString folderPath;
 127
 128         //Now try to get the folder path!
 129         if(g_known_folders_fpGetKnownFolderPath)
 130         {
 131                 WCHAR *path = NULL;
 132                 if(g_known_folders_fpGetKnownFolderPath(s_folders[folderId].guid, KF_FLAG_CREATE, NULL, &path) == S_OK)
 133                 {
 134                         //MessageBoxW(0, path, L"SHGetKnownFolderPath", MB_TOPMOST);
 135                         QDir folderTemp = QDir(QDir::fromNativeSeparators(MUTILS_WCHAR2QSTR(path)));
 136                         if(folderTemp.exists())
 137                         {
 138                                 folderPath = folderTemp.canonicalPath();
 139                         }
 140                         CoTaskMemFree(path);
 141                 }
 142         }
 143         else if(g_known_folders_fpGetFolderPath)
 144         {
 145                 QScopedArrayPointer<WCHAR> path(new WCHAR[4096]);
 146                 if(g_known_folders_fpGetFolderPath(NULL, s_folders[folderId].csidl | CSIDL_FLAG_CREATE, NULL, NULL, path.data()) == S_OK)
 147                 {
 148                         //MessageBoxW(0, path, L"SHGetFolderPathW", MB_TOPMOST);
 149                         QDir folderTemp = QDir(QDir::fromNativeSeparators(MUTILS_WCHAR2QSTR(path.data())));
 150                         if(folderTemp.exists())
 151                         {
 152                                 folderPath = folderTemp.canonicalPath();
 153                         }
 154                 }
 155         }
 156
 157         //Update cache
 158         g_known_folders_map->insert(folderId, folderPath);
 159         return g_known_folders_map->operator[](folderId);
 160 }
 161
 162 ///////////////////////////////////////////////////////////////////////////////
 163 // CURRENT DATA (SAFE)
 164 ///////////////////////////////////////////////////////////////////////////////
 165
 166 QDate MUtils::OS::current_date(void)
 167 {
 168         const DWORD MAX_PROC = 1024;
 169         QScopedArrayPointer<DWORD> processes(new DWORD[MAX_PROC]);
 170         DWORD bytesReturned = 0;
 171
 172         if(!EnumProcesses(processes.data(), sizeof(DWORD) * MAX_PROC, &bytesReturned))
 173         {
 174                 return QDate::currentDate();
 175         }
 176
 177         const DWORD procCount = bytesReturned / sizeof(DWORD);
 178         ULARGE_INTEGER lastStartTime;
 179         memset(&lastStartTime, 0, sizeof(ULARGE_INTEGER));
 180
 181         for(DWORD i = 0; i < procCount; i++)
 182         {
 183                 if(HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, processes[i]))
 184                 {
 185                         FILETIME processTime[4];
 186                         if(GetProcessTimes(hProc, &processTime[0], &processTime[1], &processTime[2], &processTime[3]))
 187                         {
 188                                 ULARGE_INTEGER timeCreation;
 189                                 timeCreation.LowPart  = processTime[0].dwLowDateTime;
 190                                 timeCreation.HighPart = processTime[0].dwHighDateTime;
 191                                 if(timeCreation.QuadPart > lastStartTime.QuadPart)
 192                                 {
 193                                         lastStartTime.QuadPart = timeCreation.QuadPart;
 194                                 }
 195                         }
 196                         CloseHandle(hProc);
 197                 }
 198         }
 199
 200         FILETIME lastStartTime_fileTime;
 201         lastStartTime_fileTime.dwHighDateTime = lastStartTime.HighPart;
 202         lastStartTime_fileTime.dwLowDateTime  = lastStartTime.LowPart;
 203
 204         FILETIME lastStartTime_localTime;
 205         if(!FileTimeToLocalFileTime(&lastStartTime_fileTime, &lastStartTime_localTime))
 206         {
 207                 memcpy(&lastStartTime_localTime, &lastStartTime_fileTime, sizeof(FILETIME));
 208         }
 209
 210         SYSTEMTIME lastStartTime_system;
 211         if(!FileTimeToSystemTime(&lastStartTime_localTime, &lastStartTime_system))
 212         {
 213                 memset(&lastStartTime_system, 0, sizeof(SYSTEMTIME));
 214                 lastStartTime_system.wYear = 1970; lastStartTime_system.wMonth = lastStartTime_system.wDay = 1;
 215         }
 216
 217         const QDate currentDate = QDate::currentDate();
 218         const QDate processDate = QDate(lastStartTime_system.wYear, lastStartTime_system.wMonth, lastStartTime_system.wDay);
 219         return (currentDate >= processDate) ? currentDate : processDate;
 220 }
 221
 222 ///////////////////////////////////////////////////////////////////////////////
 223 // FATAL EXIT
 224 ///////////////////////////////////////////////////////////////////////////////
 225
 226 static CriticalSection g_fatal_exit_lock;
 227 static volatile bool   g_fatal_exit_flag = true;
 228
 229 static DWORD WINAPI fatal_exit_helper(LPVOID lpParameter)
 230 {
 231         MessageBoxA(NULL, ((LPCSTR) lpParameter), "LameXP - Guru Meditation", MB_OK | MB_ICONERROR | MB_TASKMODAL | MB_TOPMOST | MB_SETFOREGROUND);
 232         return 0;
 233 }
 234
 235 void MUtils::OS::fatal_exit(const char* const errorMessage)
 236 {
 237         g_fatal_exit_lock.enter();
 238
 239         if(!g_fatal_exit_flag)
 240         {
 241                 return; /*prevent recursive invocation*/
 242         }
 243
 244         g_fatal_exit_flag = false;
 245
 246         if(g_main_thread_id != GetCurrentThreadId())
 247         {
 248                 if(HANDLE hThreadMain = OpenThread(THREAD_SUSPEND_RESUME, FALSE, g_main_thread_id))
 249                 {
 250                         SuspendThread(hThreadMain); /*stop main thread*/
 251                 }
 252         }
 253
 254         if(HANDLE hThread = CreateThread(NULL, 0, fatal_exit_helper, (LPVOID) errorMessage, 0, NULL))
 255         {
 256                 WaitForSingleObject(hThread, INFINITE);
 257         }
 258
 259         for(;;)
 260         {
 261                 TerminateProcess(GetCurrentProcess(), 666);
 262         }
 263 }
 264
 265 ///////////////////////////////////////////////////////////////////////////////