src/OSSupport_Win32.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2015 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 //Win32 API
  23 #define WIN32_LEAN_AND_MEAN 1
  24 #include <Windows.h>
  25 #include <Objbase.h>
  26 #include <Psapi.h>
  27 #include <Sensapi.h>
  28 #include <Shellapi.h>
  29 #include <PowrProf.h>
  30 #include <Mmsystem.h>
  31
  32 //Internal
  33 #include <MUtils/Global.h>
  34 #include <MUtils/OSSupport.h>
  35 #include <MUtils/GUI.h>
  36 #include "CriticalSection_Win32.h"
  37
  38 //Qt
  39 #include <QMap>
  40 #include <QReadWriteLock>
  41 #include <QLibrary>
  42 #include <QDir>
  43 #include <QWidget>
  44 #include <QProcess>
  45
  46 //Main thread ID
  47 static const DWORD g_main_thread_id = GetCurrentThreadId();
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // SYSTEM MESSAGE
  51 ///////////////////////////////////////////////////////////////////////////////
  52
  53 static const UINT g_msgBoxFlags = MB_TOPMOST | MB_TASKMODAL | MB_SETFOREGROUND;
  54
  55 void MUtils::OS::system_message_nfo(const wchar_t *const title, const wchar_t *const text)
  56 {
  57         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONINFORMATION);
  58 }
  59
  60 void MUtils::OS::system_message_wrn(const wchar_t *const title, const wchar_t *const text)
  61 {
  62         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONWARNING);
  63 }
  64
  65 void MUtils::OS::system_message_err(const wchar_t *const title, const wchar_t *const text)
  66 {
  67         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONERROR);
  68 }
  69
  70 ///////////////////////////////////////////////////////////////////////////////
  71 // FETCH CLI ARGUMENTS
  72 ///////////////////////////////////////////////////////////////////////////////
  73
  74 static QReadWriteLock                          g_arguments_lock;
  75 static QScopedPointer<MUtils::OS::ArgumentMap> g_arguments_list;
  76
  77 const MUtils::OS::ArgumentMap &MUtils::OS::arguments(void)
  78 {
  79         QReadLocker readLock(&g_arguments_lock);
  80
  81         //Already initialized?
  82         if(!g_arguments_list.isNull())
  83         {
  84                 return (*(g_arguments_list.data()));
  85         }
  86
  87         readLock.unlock();
  88         QWriteLocker writeLock(&g_arguments_lock);
  89
  90         //Still not initialized?
  91         if(!g_arguments_list.isNull())
  92         {
  93                 return (*(g_arguments_list.data()));
  94         }
  95
  96         g_arguments_list.reset(new ArgumentMap());
  97         int nArgs = 0;
  98         LPWSTR *szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
  99
 100         if(NULL != szArglist)
 101         {
 102                 const QChar separator = QLatin1Char('=');
 103                 const QString argPrefix = QLatin1String("--");
 104                 for(int i = 0; i < nArgs; i++)
 105                 {
 106                         const QString argStr = MUTILS_QSTR(szArglist[i]).trimmed();
 107                         if(argStr.startsWith(argPrefix))
 108                         {
 109                                 const QString argData = argStr.mid(2).trimmed();
 110                                 if(argData.length() > 0)
 111                                 {
 112                                         const int separatorIndex = argData.indexOf(separator);
 113                                         if(separatorIndex > 0)
 114                                         {
 115                                                 const QString argKey = argData.left(separatorIndex).trimmed();
 116                                                 const QString argVal = argData.mid(separatorIndex + 1).trimmed();
 117                                                 g_arguments_list->insertMulti(argKey.toLower(), argVal);
 118                                         }
 119                                         else
 120                                         {
 121                                                 g_arguments_list->insertMulti(argData.toLower(), QString());
 122                                         }
 123                                 }
 124                         }
 125                 }
 126                 LocalFree(szArglist);
 127         }
 128         else
 129         {
 130                 qWarning("CommandLineToArgvW() has failed !!!");
 131         }
 132
 133         return (*(g_arguments_list.data()));
 134 }
 135
 136 ///////////////////////////////////////////////////////////////////////////////
 137 // COPY FILE
 138 ///////////////////////////////////////////////////////////////////////////////
 139
 140 typedef struct _progress_callback_data_t
 141 {
 142         MUtils::OS::progress_callback_t callback_function;
 143         void *user_data;
 144 }
 145 progress_callback_data_t;
 146
 147 static DWORD __stdcall copy_file_progress(LARGE_INTEGER TotalFileSize, LARGE_INTEGER TotalBytesTransferred, LARGE_INTEGER StreamSize, LARGE_INTEGER StreamBytesTransferred, DWORD dwStreamNumber, DWORD dwCallbackReason, HANDLE hSourceFile, HANDLE hDestinationFile, LPVOID lpData)
 148 {
 149         if(const progress_callback_data_t *data = (progress_callback_data_t*) lpData)
 150         {
 151                 const double progress = qBound(0.0, double(TotalBytesTransferred.QuadPart) / double(TotalFileSize.QuadPart), 1.0);
 152                 return data->callback_function(progress, data->user_data) ? PROGRESS_CONTINUE : PROGRESS_CANCEL;
 153         }
 154         return PROGRESS_CONTINUE;
 155 }
 156
 157 MUTILS_API bool MUtils::OS::copy_file(const QString &sourcePath, const QString &outputPath, const bool &overwrite, const progress_callback_t callback, void *const userData)
 158 {
 159         progress_callback_data_t callback_data = { callback, userData };
 160         BOOL cancel = FALSE;
 161         const BOOL result = CopyFileExW(MUTILS_WCHR(QDir::toNativeSeparators(sourcePath)), MUTILS_WCHR(QDir::toNativeSeparators(outputPath)), ((callback_data.callback_function) ? copy_file_progress : NULL), ((callback_data.callback_function) ? &callback_data : NULL), &cancel, (overwrite ? 0 : COPY_FILE_FAIL_IF_EXISTS));
 162
 163         if(result == FALSE)
 164         {
 165                 const DWORD errorCode = GetLastError();
 166                 if(errorCode != ERROR_REQUEST_ABORTED)
 167                 {
 168                         qWarning("CopyFile() failed with error code 0x%08X!", errorCode);
 169                 }
 170                 else
 171                 {
 172                         qWarning("CopyFile() operation was abroted by user!");
 173                 }
 174         }
 175
 176         return (result != FALSE);
 177 }
 178
 179 ///////////////////////////////////////////////////////////////////////////////
 180 // OS VERSION DETECTION
 181 ///////////////////////////////////////////////////////////////////////////////
 182
 183 static bool g_os_version_initialized = false;
 184 static MUtils::OS::Version::os_version_t g_os_version_info = MUtils::OS::Version::UNKNOWN_OPSYS;
 185 static QReadWriteLock g_os_version_lock;
 186
 187 //Maps marketing names to the actual Windows NT versions
 188 static const struct
 189 {
 190         MUtils::OS::Version::os_version_t version;
 191         const char friendlyName[64];
 192 }
 193 g_os_version_lut[] =
 194 {
 195         { MUtils::OS::Version::WINDOWS_WIN2K, "Windows 2000"                                  },        //2000
 196         { MUtils::OS::Version::WINDOWS_WINXP, "Windows XP or Windows XP Media Center Edition" },        //XP
 197         { MUtils::OS::Version::WINDOWS_XPX64, "Windows Server 2003 or Windows XP x64"         },        //XP_x64
 198         { MUtils::OS::Version::WINDOWS_VISTA, "Windows Vista or Windows Server 2008"          },        //Vista
 199         { MUtils::OS::Version::WINDOWS_WIN70, "Windows 7 or Windows Server 2008 R2"           },        //7
 200         { MUtils::OS::Version::WINDOWS_WIN80, "Windows 8 or Windows Server 2012"              },        //8
 201         { MUtils::OS::Version::WINDOWS_WIN81, "Windows 8.1 or Windows Server 2012 R2"         },        //8.1
 202         { MUtils::OS::Version::WINDOWS_WN100, "Windows 10 or Windows Server 2014 (Preview)"   },        //10
 203         { MUtils::OS::Version::UNKNOWN_OPSYS, "N/A" }
 204 };
 205
 206 //OS version data dtructures
 207 namespace MUtils
 208 {
 209         namespace OS
 210         {
 211                 namespace Version
 212                 {
 213                         //Comparision operators for os_version_t
 214                         bool os_version_t::operator== (const os_version_t &rhs) const { return (type == rhs.type) && (versionMajor == rhs.versionMajor) && ((versionMinor == rhs.versionMinor)); }
 215                         bool os_version_t::operator!= (const os_version_t &rhs) const { return (type != rhs.type) || (versionMajor != rhs.versionMajor) || ((versionMinor != rhs.versionMinor)); }
 216                         bool os_version_t::operator>  (const os_version_t &rhs) const { return (type == rhs.type) && ((versionMajor > rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor >  rhs.versionMinor))); }
 217                         bool os_version_t::operator>= (const os_version_t &rhs) const { return (type == rhs.type) && ((versionMajor > rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor >= rhs.versionMinor))); }
 218                         bool os_version_t::operator<  (const os_version_t &rhs) const { return (type == rhs.type) && ((versionMajor < rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor <  rhs.versionMinor))); }
 219                         bool os_version_t::operator<= (const os_version_t &rhs) const { return (type == rhs.type) && ((versionMajor < rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor <= rhs.versionMinor))); }
 220
 221                         //Known Windows NT versions
 222                         const os_version_t WINDOWS_WIN2K = { OS_WINDOWS,  5, 0 };       // 2000
 223                         const os_version_t WINDOWS_WINXP = { OS_WINDOWS,  5, 1 };       // XP
 224                         const os_version_t WINDOWS_XPX64 = { OS_WINDOWS,  5, 2 };       // XP_x64
 225                         const os_version_t WINDOWS_VISTA = { OS_WINDOWS,  6, 0 };       // Vista
 226                         const os_version_t WINDOWS_WIN70 = { OS_WINDOWS,  6, 1 };       // 7
 227                         const os_version_t WINDOWS_WIN80 = { OS_WINDOWS,  6, 2 };       // 8
 228                         const os_version_t WINDOWS_WIN81 = { OS_WINDOWS,  6, 3 };       // 8.1
 229                         const os_version_t WINDOWS_WN100 = { OS_WINDOWS, 10, 0 };       // 10
 230
 231                         //Unknown OS
 232                         const os_version_t UNKNOWN_OPSYS = { OS_UNKNOWN, 0, 0 };        // N/A
 233                 }
 234         }
 235 }
 236
 237 static bool verify_os_version(const DWORD major, const DWORD minor)
 238 {
 239         OSVERSIONINFOEXW osvi;
 240         DWORDLONG dwlConditionMask = 0;
 241
 242         //Initialize the OSVERSIONINFOEX structure
 243         memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
 244         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
 245         osvi.dwMajorVersion = major;
 246         osvi.dwMinorVersion = minor;
 247         osvi.dwPlatformId = VER_PLATFORM_WIN32_NT;
 248
 249         //Initialize the condition mask
 250         VER_SET_CONDITION(dwlConditionMask, VER_MAJORVERSION, VER_GREATER_EQUAL);
 251         VER_SET_CONDITION(dwlConditionMask, VER_MINORVERSION, VER_GREATER_EQUAL);
 252         VER_SET_CONDITION(dwlConditionMask, VER_PLATFORMID,   VER_EQUAL);
 253
 254         // Perform the test
 255         const BOOL ret = VerifyVersionInfoW(&osvi, VER_MAJORVERSION | VER_MINORVERSION | VER_PLATFORMID, dwlConditionMask);
 256
 257         //Error checking
 258         if(!ret)
 259         {
 260                 if(GetLastError() != ERROR_OLD_WIN_VERSION)
 261                 {
 262                         qWarning("VerifyVersionInfo() system call has failed!");
 263                 }
 264         }
 265
 266         return (ret != FALSE);
 267 }
 268
 269 static bool get_real_os_version(unsigned int *major, unsigned int *minor, bool *pbOverride)
 270 {
 271         *major = *minor = 0;
 272         *pbOverride = false;
 273
 274         //Initialize local variables
 275         OSVERSIONINFOEXW osvi;
 276         memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
 277         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
 278
 279         //Try GetVersionEx() first
 280         if(GetVersionExW((LPOSVERSIONINFOW)&osvi) == FALSE)
 281         {
 282                 qWarning("GetVersionEx() has failed, cannot detect Windows version!");
 283                 return false;
 284         }
 285
 286         //Make sure we are running on NT
 287         if(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 288         {
 289                 *major = osvi.dwMajorVersion;
 290                 *minor = osvi.dwMinorVersion;
 291         }
 292         else
 293         {
 294                 qWarning("Not running on Windows NT, unsupported operating system!");
 295                 return false;
 296         }
 297
 298         //Determine the real *major* version first
 299         forever
 300         {
 301                 const DWORD nextMajor = (*major) + 1;
 302                 if(verify_os_version(nextMajor, 0))
 303                 {
 304                         *pbOverride = true;
 305                         *major = nextMajor;
 306                         *minor = 0;
 307                         continue;
 308                 }
 309                 break;
 310         }
 311
 312         //Now also determine the real *minor* version
 313         forever
 314         {
 315                 const DWORD nextMinor = (*minor) + 1;
 316                 if(verify_os_version((*major), nextMinor))
 317                 {
 318                         *pbOverride = true;
 319                         *minor = nextMinor;
 320                         continue;
 321                 }
 322                 break;
 323         }
 324
 325         return true;
 326 }
 327
 328 const MUtils::OS::Version::os_version_t &MUtils::OS::os_version(void)
 329 {
 330         QReadLocker readLock(&g_os_version_lock);
 331
 332         //Already initialized?
 333         if(g_os_version_initialized)
 334         {
 335                 return g_os_version_info;
 336         }
 337
 338         readLock.unlock();
 339         QWriteLocker writeLock(&g_os_version_lock);
 340
 341         //Initialized now?
 342         if(g_os_version_initialized)
 343         {
 344                 return g_os_version_info;
 345         }
 346
 347         //Detect OS version
 348         unsigned int major, minor; bool overrideFlg;
 349         if(get_real_os_version(&major, &minor, &overrideFlg))
 350         {
 351                 g_os_version_info.type = Version::OS_WINDOWS;
 352                 g_os_version_info.versionMajor = major;
 353                 g_os_version_info.versionMinor = minor;
 354                 g_os_version_info.overrideFlag = overrideFlg;
 355         }
 356         else
 357         {
 358                 qWarning("Failed to determin the operating system version!");
 359         }
 360
 361         //Completed
 362         g_os_version_initialized = true;
 363         return g_os_version_info;
 364 }
 365
 366 const char *MUtils::OS::os_friendly_name(const MUtils::OS::Version::os_version_t &os_version)
 367 {
 368         for(size_t i = 0; g_os_version_lut[i].version != MUtils::OS::Version::UNKNOWN_OPSYS; i++)
 369         {
 370                 if(os_version == g_os_version_lut[i].version)
 371                 {
 372                         return g_os_version_lut[i].friendlyName;
 373                 }
 374         }
 375
 376         return NULL;
 377 }
 378
 379 ///////////////////////////////////////////////////////////////////////////////
 380 // WINE DETECTION
 381 ///////////////////////////////////////////////////////////////////////////////
 382
 383 static bool g_wine_deteced = false;
 384 static bool g_wine_initialized = false;
 385 static QReadWriteLock g_wine_lock;
 386
 387 static const bool detect_wine(void)
 388 {
 389         bool is_wine = false;
 390
 391         QLibrary ntdll("ntdll.dll");
 392         if(ntdll.load())
 393         {
 394                 if(ntdll.resolve("wine_nt_to_unix_file_name") != NULL) is_wine = true;
 395                 if(ntdll.resolve("wine_get_version")          != NULL) is_wine = true;
 396                 ntdll.unload();
 397         }
 398
 399         return is_wine;
 400 }
 401
 402 const bool &MUtils::OS::running_on_wine(void)
 403 {
 404         QReadLocker readLock(&g_wine_lock);
 405
 406         //Already initialized?
 407         if(g_wine_initialized)
 408         {
 409                 return g_wine_deteced;
 410         }
 411
 412         readLock.unlock();
 413         QWriteLocker writeLock(&g_wine_lock);
 414
 415         //Initialized now?
 416         if(g_wine_initialized)
 417         {
 418                 return g_wine_deteced;
 419         }
 420
 421         //Try to detect Wine
 422         g_wine_deteced = detect_wine();
 423         g_wine_initialized = true;
 424
 425         return g_wine_deteced;
 426 }
 427
 428 ///////////////////////////////////////////////////////////////////////////////
 429 // KNWON FOLDERS
 430 ///////////////////////////////////////////////////////////////////////////////
 431
 432 typedef QMap<size_t, QString> KFMap;
 433 typedef HRESULT (WINAPI *SHGetKnownFolderPath_t)(const GUID &rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
 434 typedef HRESULT (WINAPI *SHGetFolderPath_t)(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
 435
 436 static QScopedPointer<KFMap>  g_known_folders_map;
 437 static SHGetKnownFolderPath_t g_known_folders_fpGetKnownFolderPath;
 438 static SHGetFolderPath_t      g_known_folders_fpGetFolderPath;
 439 static QReadWriteLock         g_known_folders_lock;
 440
 441 const QString &MUtils::OS::known_folder(known_folder_t folder_id)
 442 {
 443         static const int CSIDL_FLAG_CREATE = 0x8000;
 444         typedef enum { KF_FLAG_CREATE = 0x00008000 } kf_flags_t;
 445
 446         struct
 447         {
 448                 const int csidl;
 449                 const GUID guid;
 450         }
 451         static s_folders[] =
 452         {
 453                 { 0x001c, {0xF1B32785,0x6FBA,0x4FCF,{0x9D,0x55,0x7B,0x8E,0x7F,0x15,0x70,0x91}} },  //CSIDL_LOCAL_APPDATA
 454                 { 0x0026, {0x905e63b6,0xc1bf,0x494e,{0xb2,0x9c,0x65,0xb7,0x32,0xd3,0xd2,0x1a}} },  //CSIDL_PROGRAM_FILES
 455                 { 0x0024, {0xF38BF404,0x1D43,0x42F2,{0x93,0x05,0x67,0xDE,0x0B,0x28,0xFC,0x23}} },  //CSIDL_WINDOWS_FOLDER
 456                 { 0x0025, {0x1AC14E77,0x02E7,0x4E5D,{0xB7,0x44,0x2E,0xB1,0xAE,0x51,0x98,0xB7}} },  //CSIDL_SYSTEM_FOLDER
 457         };
 458
 459         size_t folderId = size_t(-1);
 460
 461         switch(folder_id)
 462         {
 463                 case FOLDER_LOCALAPPDATA: folderId = 0; break;
 464                 case FOLDER_PROGRAMFILES: folderId = 1; break;
 465                 case FOLDER_SYSTROOT_DIR: folderId = 2; break;
 466                 case FOLDER_SYSTEMFOLDER: folderId = 3; break;
 467         }
 468
 469         if(folderId == size_t(-1))
 470         {
 471                 qWarning("Invalid 'known' folder was requested!");
 472                 return *reinterpret_cast<QString*>(NULL);
 473         }
 474
 475         QReadLocker readLock(&g_known_folders_lock);
 476
 477         //Already in cache?
 478         if(!g_known_folders_map.isNull())
 479         {
 480                 if(g_known_folders_map->contains(folderId))
 481                 {
 482                         return g_known_folders_map->operator[](folderId);
 483                 }
 484         }
 485
 486         //Obtain write lock to initialize
 487         readLock.unlock();
 488         QWriteLocker writeLock(&g_known_folders_lock);
 489
 490         //Still not in cache?
 491         if(!g_known_folders_map.isNull())
 492         {
 493                 if(g_known_folders_map->contains(folderId))
 494                 {
 495                         return g_known_folders_map->operator[](folderId);
 496                 }
 497         }
 498
 499         //Initialize on first call
 500         if(g_known_folders_map.isNull())
 501         {
 502                 QLibrary shell32("shell32.dll");
 503                 if(shell32.load())
 504                 {
 505                         g_known_folders_fpGetFolderPath =      (SHGetFolderPath_t)      shell32.resolve("SHGetFolderPathW");
 506                         g_known_folders_fpGetKnownFolderPath = (SHGetKnownFolderPath_t) shell32.resolve("SHGetKnownFolderPath");
 507                 }
 508                 g_known_folders_map.reset(new QMap<size_t, QString>());
 509         }
 510
 511         QString folderPath;
 512
 513         //Now try to get the folder path!
 514         if(g_known_folders_fpGetKnownFolderPath)
 515         {
 516                 WCHAR *path = NULL;
 517                 if(g_known_folders_fpGetKnownFolderPath(s_folders[folderId].guid, KF_FLAG_CREATE, NULL, &path) == S_OK)
 518                 {
 519                         //MessageBoxW(0, path, L"SHGetKnownFolderPath", MB_TOPMOST);
 520                         QDir folderTemp = QDir(QDir::fromNativeSeparators(MUTILS_QSTR(path)));
 521                         if(folderTemp.exists())
 522                         {
 523                                 folderPath = folderTemp.canonicalPath();
 524                         }
 525                         CoTaskMemFree(path);
 526                 }
 527         }
 528         else if(g_known_folders_fpGetFolderPath)
 529         {
 530                 QScopedArrayPointer<WCHAR> path(new WCHAR[4096]);
 531                 if(g_known_folders_fpGetFolderPath(NULL, s_folders[folderId].csidl | CSIDL_FLAG_CREATE, NULL, NULL, path.data()) == S_OK)
 532                 {
 533                         //MessageBoxW(0, path, L"SHGetFolderPathW", MB_TOPMOST);
 534                         QDir folderTemp = QDir(QDir::fromNativeSeparators(MUTILS_QSTR(path.data())));
 535                         if(folderTemp.exists())
 536                         {
 537                                 folderPath = folderTemp.canonicalPath();
 538                         }
 539                 }
 540         }
 541
 542         //Update cache
 543         g_known_folders_map->insert(folderId, folderPath);
 544         return g_known_folders_map->operator[](folderId);
 545 }
 546
 547 ///////////////////////////////////////////////////////////////////////////////
 548 // CURRENT DATA & TIME
 549 ///////////////////////////////////////////////////////////////////////////////
 550
 551 QDate MUtils::OS::current_date(void)
 552 {
 553         const DWORD MAX_PROC = 1024;
 554         QScopedArrayPointer<DWORD> processes(new DWORD[MAX_PROC]);
 555         DWORD bytesReturned = 0;
 556
 557         if(!EnumProcesses(processes.data(), sizeof(DWORD) * MAX_PROC, &bytesReturned))
 558         {
 559                 return QDate::currentDate();
 560         }
 561
 562         const DWORD procCount = bytesReturned / sizeof(DWORD);
 563         ULARGE_INTEGER lastStartTime;
 564         memset(&lastStartTime, 0, sizeof(ULARGE_INTEGER));
 565
 566         for(DWORD i = 0; i < procCount; i++)
 567         {
 568                 if(HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, processes[i]))
 569                 {
 570                         FILETIME processTime[4];
 571                         if(GetProcessTimes(hProc, &processTime[0], &processTime[1], &processTime[2], &processTime[3]))
 572                         {
 573                                 ULARGE_INTEGER timeCreation;
 574                                 timeCreation.LowPart  = processTime[0].dwLowDateTime;
 575                                 timeCreation.HighPart = processTime[0].dwHighDateTime;
 576                                 if(timeCreation.QuadPart > lastStartTime.QuadPart)
 577                                 {
 578                                         lastStartTime.QuadPart = timeCreation.QuadPart;
 579                                 }
 580                         }
 581                         CloseHandle(hProc);
 582                 }
 583         }
 584
 585         FILETIME lastStartTime_fileTime;
 586         lastStartTime_fileTime.dwHighDateTime = lastStartTime.HighPart;
 587         lastStartTime_fileTime.dwLowDateTime  = lastStartTime.LowPart;
 588
 589         FILETIME lastStartTime_localTime;
 590         if(!FileTimeToLocalFileTime(&lastStartTime_fileTime, &lastStartTime_localTime))
 591         {
 592                 memcpy(&lastStartTime_localTime, &lastStartTime_fileTime, sizeof(FILETIME));
 593         }
 594
 595         SYSTEMTIME lastStartTime_system;
 596         if(!FileTimeToSystemTime(&lastStartTime_localTime, &lastStartTime_system))
 597         {
 598                 memset(&lastStartTime_system, 0, sizeof(SYSTEMTIME));
 599                 lastStartTime_system.wYear = 1970; lastStartTime_system.wMonth = lastStartTime_system.wDay = 1;
 600         }
 601
 602         const QDate currentDate = QDate::currentDate();
 603         const QDate processDate = QDate(lastStartTime_system.wYear, lastStartTime_system.wMonth, lastStartTime_system.wDay);
 604         return (currentDate >= processDate) ? currentDate : processDate;
 605 }
 606
 607 quint64 MUtils::OS::current_file_time(void)
 608 {
 609         FILETIME fileTime;
 610         GetSystemTimeAsFileTime(&fileTime);
 611
 612         ULARGE_INTEGER temp;
 613         temp.HighPart = fileTime.dwHighDateTime;
 614         temp.LowPart = fileTime.dwLowDateTime;
 615
 616         return temp.QuadPart;
 617 }
 618
 619 ///////////////////////////////////////////////////////////////////////////////
 620 // PROCESS ELEVATION
 621 ///////////////////////////////////////////////////////////////////////////////
 622
 623 static bool user_is_admin_helper(void)
 624 {
 625         HANDLE hToken = NULL;
 626         if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 627         {
 628                 return false;
 629         }
 630
 631         DWORD dwSize = 0;
 632         if(!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
 633         {
 634                 if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 635                 {
 636                         CloseHandle(hToken);
 637                         return false;
 638                 }
 639         }
 640
 641         PTOKEN_GROUPS lpGroups = (PTOKEN_GROUPS) malloc(dwSize);
 642         if(!lpGroups)
 643         {
 644                 CloseHandle(hToken);
 645                 return false;
 646         }
 647
 648         if(!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
 649         {
 650                 free(lpGroups);
 651                 CloseHandle(hToken);
 652                 return false;
 653         }
 654
 655         PSID lpSid = NULL; SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
 656         if(!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &lpSid))
 657         {
 658                 free(lpGroups);
 659                 CloseHandle(hToken);
 660                 return false;
 661         }
 662
 663         bool bResult = false;
 664         for(DWORD i = 0; i < lpGroups->GroupCount; i++)
 665         {
 666                 if(EqualSid(lpSid, lpGroups->Groups[i].Sid))
 667                 {
 668                         bResult = true;
 669                         break;
 670                 }
 671         }
 672
 673         FreeSid(lpSid);
 674         free(lpGroups);
 675         CloseHandle(hToken);
 676         return bResult;
 677 }
 678
 679 bool MUtils::OS::is_elevated(bool *bIsUacEnabled)
 680 {
 681         if(bIsUacEnabled)
 682         {
 683                 *bIsUacEnabled = false;
 684         }
 685
 686         bool bIsProcessElevated = false;
 687         HANDLE hToken = NULL;
 688
 689         if(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 690         {
 691                 TOKEN_ELEVATION_TYPE tokenElevationType;
 692                 DWORD returnLength;
 693                 if(GetTokenInformation(hToken, TokenElevationType, &tokenElevationType, sizeof(TOKEN_ELEVATION_TYPE), &returnLength))
 694                 {
 695                         if(returnLength == sizeof(TOKEN_ELEVATION_TYPE))
 696                         {
 697                                 switch(tokenElevationType)
 698                                 {
 699                                 case TokenElevationTypeDefault:
 700                                         qDebug("Process token elevation type: Default -> UAC is disabled.\n");
 701                                         break;
 702                                 case TokenElevationTypeFull:
 703                                         qWarning("Process token elevation type: Full -> potential security risk!\n");
 704                                         bIsProcessElevated = true;
 705                                         if(bIsUacEnabled) *bIsUacEnabled = true;
 706                                         break;
 707                                 case TokenElevationTypeLimited:
 708                                         qDebug("Process token elevation type: Limited -> not elevated.\n");
 709                                         if(bIsUacEnabled) *bIsUacEnabled = true;
 710                                         break;
 711                                 default:
 712                                         qWarning("Unknown tokenElevationType value: %d", tokenElevationType);
 713                                         break;
 714                                 }
 715                         }
 716                         else
 717                         {
 718                                 qWarning("GetTokenInformation() return an unexpected size!");
 719                         }
 720                 }
 721                 CloseHandle(hToken);
 722         }
 723         else
 724         {
 725                 qWarning("Failed to open process token!");
 726         }
 727
 728         return bIsProcessElevated;
 729 }
 730
 731 bool MUtils::OS::user_is_admin(void)
 732 {
 733         bool isAdmin = false;
 734
 735         //Check for process elevation and UAC support first!
 736         if(MUtils::OS::is_elevated(&isAdmin))
 737         {
 738                 qWarning("Process is elevated -> user is admin!");
 739                 return true;
 740         }
 741
 742         //If not elevated and UAC is not available -> user must be in admin group!
 743         if(!isAdmin)
 744         {
 745                 qDebug("UAC is disabled/unavailable -> checking for Administrators group");
 746                 isAdmin = user_is_admin_helper();
 747         }
 748
 749         return isAdmin;
 750 }
 751
 752 ///////////////////////////////////////////////////////////////////////////////
 753 // NETWORK STATE
 754 ///////////////////////////////////////////////////////////////////////////////
 755
 756 int MUtils::OS::network_status(void)
 757 {
 758         DWORD dwFlags;
 759         const BOOL ret = IsNetworkAlive(&dwFlags);
 760         if(GetLastError() == 0)
 761         {
 762                 return (ret != FALSE) ? NETWORK_TYPE_YES : NETWORK_TYPE_NON;
 763         }
 764         return NETWORK_TYPE_ERR;
 765 }
 766
 767 ///////////////////////////////////////////////////////////////////////////////
 768 // MESSAGE HANDLER
 769 ///////////////////////////////////////////////////////////////////////////////
 770
 771 bool MUtils::OS::handle_os_message(const void *const message, long *result)
 772 {
 773         const MSG *const msg = reinterpret_cast<const MSG*>(message);
 774
 775         switch(msg->message)
 776         {
 777         case WM_QUERYENDSESSION:
 778                 qWarning("WM_QUERYENDSESSION message received!");
 779                 *result = MUtils::GUI::broadcast(MUtils::GUI::USER_EVENT_QUERYENDSESSION, false) ? TRUE : FALSE;
 780                 return true;
 781         case WM_ENDSESSION:
 782                 qWarning("WM_ENDSESSION message received!");
 783                 if(msg->wParam == TRUE)
 784                 {
 785                         MUtils::GUI::broadcast(MUtils::GUI::USER_EVENT_ENDSESSION, false);
 786                         MUtils::GUI::force_quit();
 787                         exit(1);
 788                 }
 789                 *result = 0;
 790                 return true;
 791         default:
 792                 /*ignore this message and let Qt handle it*/
 793                 return false;
 794         }
 795 }
 796
 797 ///////////////////////////////////////////////////////////////////////////////
 798 // SLEEP
 799 ///////////////////////////////////////////////////////////////////////////////
 800
 801 void MUtils::OS::sleep_ms(const size_t &duration)
 802 {
 803         Sleep((DWORD) duration);
 804 }
 805
 806 ///////////////////////////////////////////////////////////////////////////////
 807 // EXECUTABLE CHECK
 808 ///////////////////////////////////////////////////////////////////////////////
 809
 810 bool MUtils::OS::is_executable_file(const QString &path)
 811 {
 812         bool bIsExecutable = false;
 813         DWORD binaryType;
 814         if(GetBinaryType(MUTILS_WCHR(QDir::toNativeSeparators(path)), &binaryType))
 815         {
 816                 bIsExecutable = (binaryType == SCS_32BIT_BINARY || binaryType == SCS_64BIT_BINARY);
 817         }
 818         return bIsExecutable;
 819 }
 820
 821 ///////////////////////////////////////////////////////////////////////////////
 822 // HIBERNATION / SHUTDOWN
 823 ///////////////////////////////////////////////////////////////////////////////
 824
 825 bool MUtils::OS::is_hibernation_supported(void)
 826 {
 827         bool hibernationSupported = false;
 828
 829         SYSTEM_POWER_CAPABILITIES pwrCaps;
 830         SecureZeroMemory(&pwrCaps, sizeof(SYSTEM_POWER_CAPABILITIES));
 831
 832         if(GetPwrCapabilities(&pwrCaps))
 833         {
 834                 hibernationSupported = pwrCaps.SystemS4 && pwrCaps.HiberFilePresent;
 835         }
 836
 837         return hibernationSupported;
 838 }
 839
 840 bool MUtils::OS::shutdown_computer(const QString &message, const unsigned long timeout, const bool forceShutdown, const bool hibernate)
 841 {
 842         HANDLE hToken = NULL;
 843
 844         if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
 845         {
 846                 TOKEN_PRIVILEGES privileges;
 847                 memset(&privileges, 0, sizeof(TOKEN_PRIVILEGES));
 848                 privileges.PrivilegeCount = 1;
 849                 privileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
 850
 851                 if(LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &privileges.Privileges[0].Luid))
 852                 {
 853                         if(AdjustTokenPrivileges(hToken, FALSE, &privileges, NULL, NULL, NULL))
 854                         {
 855                                 if(hibernate)
 856                                 {
 857                                         if(SetSuspendState(TRUE, TRUE, TRUE))
 858                                         {
 859                                                 return true;
 860                                         }
 861                                 }
 862                                 const DWORD reason = SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_FLAG_PLANNED;
 863                                 return InitiateSystemShutdownEx(NULL, const_cast<wchar_t*>(MUTILS_WCHR(message)), timeout, forceShutdown ? TRUE : FALSE, FALSE, reason);
 864                         }
 865                 }
 866         }
 867
 868         return false;
 869 }
 870
 871 ///////////////////////////////////////////////////////////////////////////////
 872 // FREE DISKSPACE
 873 ///////////////////////////////////////////////////////////////////////////////
 874
 875 bool MUtils::OS::free_diskspace(const QString &path, quint64 &freeSpace)
 876 {
 877         ULARGE_INTEGER freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
 878         if(GetDiskFreeSpaceExW(reinterpret_cast<const wchar_t*>(QDir::toNativeSeparators(path).utf16()), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes))
 879         {
 880                 freeSpace = freeBytesAvailable.QuadPart;
 881                 return true;;
 882         }
 883
 884         freeSpace = -1;
 885         return false;
 886 }
 887
 888 ///////////////////////////////////////////////////////////////////////////////
 889 // SHELL OPEN
 890 ///////////////////////////////////////////////////////////////////////////////
 891
 892 bool MUtils::OS::shell_open(const QWidget *parent, const QString &url, const QString &parameters, const QString &directory, const bool explore)
 893 {
 894         return ((int) ShellExecuteW((parent ? parent->winId() : NULL), (explore ? L"explore" : L"open"), MUTILS_WCHR(url), ((!parameters.isEmpty()) ? MUTILS_WCHR(parameters) : NULL), ((!directory.isEmpty()) ? MUTILS_WCHR(directory) : NULL), SW_SHOW)) > 32;
 895 }
 896
 897 bool MUtils::OS::shell_open(const QWidget *parent, const QString &url, const bool explore)
 898 {
 899         return shell_open(parent, url, QString(), QString(), explore);
 900 }
 901
 902 ///////////////////////////////////////////////////////////////////////////////
 903 // OPEN MEDIA FILE
 904 ///////////////////////////////////////////////////////////////////////////////
 905
 906 bool MUtils::OS::open_media_file(const QString &mediaFilePath)
 907 {
 908         const static wchar_t *registryPrefix[2] = { L"SOFTWARE\\", L"SOFTWARE\\Wow6432Node\\" };
 909         const static wchar_t *registryKeys[3] =
 910         {
 911                 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{97D341C8-B0D1-4E4A-A49A-C30B52F168E9}",
 912                 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{DB9E4EAB-2717-499F-8D56-4CC8A644AB60}",
 913                 L"foobar2000"
 914         };
 915         const static wchar_t *appNames[4] = { L"smplayer_portable.exe", L"smplayer.exe", L"MPUI.exe", L"foobar2000.exe" };
 916         const static wchar_t *valueNames[2] = { L"InstallLocation", L"InstallDir" };
 917
 918         for(size_t i = 0; i < 3; i++)
 919         {
 920                 for(size_t j = 0; j < 2; j++)
 921                 {
 922                         QString mplayerPath;
 923                         HKEY registryKeyHandle = NULL;
 924
 925                         const QString currentKey = MUTILS_QSTR(registryPrefix[j]).append(MUTILS_QSTR(registryKeys[i]));
 926                         if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, MUTILS_WCHR(currentKey), 0, KEY_READ, &registryKeyHandle) == ERROR_SUCCESS)
 927                         {
 928                                 for(size_t k = 0; k < 2; k++)
 929                                 {
 930                                         wchar_t Buffer[4096];
 931                                         DWORD BuffSize = sizeof(wchar_t*) * 4096;
 932                                         DWORD DataType = REG_NONE;
 933                                         if(RegQueryValueExW(registryKeyHandle, valueNames[k], 0, &DataType, reinterpret_cast<BYTE*>(Buffer), &BuffSize) == ERROR_SUCCESS)
 934                                         {
 935                                                 if((DataType == REG_SZ) || (DataType == REG_EXPAND_SZ) || (DataType == REG_LINK))
 936                                                 {
 937                                                         mplayerPath = MUTILS_QSTR(Buffer);
 938                                                         break;
 939                                                 }
 940                                         }
 941                                 }
 942                                 RegCloseKey(registryKeyHandle);
 943                         }
 944
 945                         if(!mplayerPath.isEmpty())
 946                         {
 947                                 QDir mplayerDir(mplayerPath);
 948                                 if(mplayerDir.exists())
 949                                 {
 950                                         for(size_t k = 0; k < 4; k++)
 951                                         {
 952                                                 if(mplayerDir.exists(MUTILS_QSTR(appNames[k])))
 953                                                 {
 954                                                         qDebug("Player found at:\n%s\n", MUTILS_UTF8(mplayerDir.absoluteFilePath(MUTILS_QSTR(appNames[k]))));
 955                                                         QProcess::startDetached(mplayerDir.absoluteFilePath(MUTILS_QSTR(appNames[k])), QStringList() << QDir::toNativeSeparators(mediaFilePath));
 956                                                         return true;
 957                                                 }
 958                                         }
 959                                 }
 960                         }
 961                 }
 962         }
 963         return false;
 964 }
 965
 966 ///////////////////////////////////////////////////////////////////////////////
 967 // DEBUGGER CHECK
 968 ///////////////////////////////////////////////////////////////////////////////
 969
 970 static bool change_process_priority_helper(const HANDLE hProcess, const int priority)
 971 {
 972         bool ok = false;
 973
 974         switch(qBound(-2, priority, 2))
 975         {
 976         case 2:
 977                 ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
 978                 break;
 979         case 1:
 980                 if(!(ok = (SetPriorityClass(hProcess, ABOVE_NORMAL_PRIORITY_CLASS) == TRUE)))
 981                 {
 982                         ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
 983                 }
 984                 break;
 985         case 0:
 986                 ok = (SetPriorityClass(hProcess, NORMAL_PRIORITY_CLASS) == TRUE);
 987                 break;
 988         case -1:
 989                 if(!(ok = (SetPriorityClass(hProcess, BELOW_NORMAL_PRIORITY_CLASS) == TRUE)))
 990                 {
 991                         ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
 992                 }
 993                 break;
 994         case -2:
 995                 ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
 996                 break;
 997         }
 998
 999         return ok;
1000 }
1001
1002 bool MUtils::OS::change_process_priority(const int priority)
1003 {
1004         return change_process_priority_helper(GetCurrentProcess(), priority);
1005 }
1006
1007 bool MUtils::OS::change_process_priority(const QProcess *proc, const int priority)
1008 {
1009         if(Q_PID qPid = proc->pid())
1010         {
1011                 return change_process_priority_helper(qPid->hProcess, priority);
1012         }
1013         else
1014         {
1015                 return false;
1016         }
1017 }
1018
1019 ///////////////////////////////////////////////////////////////////////////////
1020 // PROCESS ID
1021 ///////////////////////////////////////////////////////////////////////////////
1022
1023 quint32 MUtils::OS::process_id(const QProcess *const proc)
1024 {
1025         PROCESS_INFORMATION *procInf = proc->pid();
1026         return (procInf) ? procInf->dwProcessId : NULL;
1027 }
1028
1029 ///////////////////////////////////////////////////////////////////////////////
1030 // PROCESS SUSPEND/RESUME
1031 ///////////////////////////////////////////////////////////////////////////////
1032
1033 bool MUtils::OS::suspend_process(const QProcess *proc, const bool suspend)
1034 {
1035         if(Q_PID pid = proc->pid())
1036         {
1037                 if(suspend)
1038                 {
1039                         return (SuspendThread(pid->hThread) != ((DWORD) -1));
1040                 }
1041                 else
1042                 {
1043                         return (ResumeThread(pid->hThread)  != ((DWORD) -1));
1044                 }
1045         }
1046         else
1047         {
1048                 return false;
1049         }
1050 }
1051
1052 ///////////////////////////////////////////////////////////////////////////////
1053 // SYSTEM TIMER
1054 ///////////////////////////////////////////////////////////////////////////////
1055
1056 bool MUtils::OS::setup_timer_resolution(const quint32 &interval)
1057 {
1058         return timeBeginPeriod(interval) == TIMERR_NOERROR;
1059 }
1060
1061 bool MUtils::OS::reset_timer_resolution(const quint32 &interval)
1062 {
1063         return timeEndPeriod(interval) == TIMERR_NOERROR;
1064 }
1065
1066 ///////////////////////////////////////////////////////////////////////////////
1067 // CHECK KEY STATE
1068 ///////////////////////////////////////////////////////////////////////////////
1069
1070 bool MUtils::OS::check_key_state_esc(void)
1071 {
1072         return (GetAsyncKeyState(VK_ESCAPE) & 0x0001) != 0;
1073 }
1074
1075 ///////////////////////////////////////////////////////////////////////////////
1076 // WOW64 REDIRECTION
1077 ///////////////////////////////////////////////////////////////////////////////
1078
1079 typedef BOOL (_stdcall *Wow64DisableWow64FsRedirectionFun)(void *OldValue);
1080 typedef BOOL (_stdcall *Wow64RevertWow64FsRedirectionFun )(void *OldValue);
1081
1082 static QReadWriteLock                    g_wow64redir_lock;
1083 static QScopedPointer<QLibrary>          g_wow64redir_kernel32;
1084 static Wow64DisableWow64FsRedirectionFun g_wow64redir_disable = NULL;
1085 static Wow64RevertWow64FsRedirectionFun  g_wow64redir_revert  = NULL;
1086
1087 static bool wow64fsredir_init()
1088 {
1089         QWriteLocker writeLock(&g_wow64redir_lock);
1090         if(g_wow64redir_disable && g_wow64redir_revert)
1091         {
1092                 return true; /*already initialized*/
1093         }
1094
1095         if(g_wow64redir_kernel32.isNull())
1096         {
1097                 g_wow64redir_kernel32.reset(new QLibrary("kernel32.dll"));
1098         }
1099
1100         if(!g_wow64redir_kernel32->isLoaded())
1101         {
1102                 if(!g_wow64redir_kernel32->load())
1103                 {
1104                         return false; /*faild to load kernel32.dll*/
1105                 }
1106         }
1107
1108         g_wow64redir_disable = (Wow64DisableWow64FsRedirectionFun) g_wow64redir_kernel32->resolve("Wow64DisableWow64FsRedirection");
1109         g_wow64redir_revert  = (Wow64RevertWow64FsRedirectionFun)  g_wow64redir_kernel32->resolve("Wow64RevertWow64FsRedirection");
1110
1111         return (g_wow64redir_disable && g_wow64redir_revert);
1112 }
1113
1114 #define WOW64FSREDIR_INIT(RDLOCK) do \
1115 { \
1116         while(!(g_wow64redir_disable && g_wow64redir_revert)) \
1117         { \
1118                 (RDLOCK).unlock(); \
1119                 if(!wow64fsredir_init()) return false; \
1120                 (RDLOCK).relock(); \
1121         } \
1122 } \
1123 while(0)
1124
1125 bool MUtils::OS::wow64fsredir_disable(void *oldValue)
1126 {
1127         QReadLocker readLock(&g_wow64redir_lock);
1128         WOW64FSREDIR_INIT(readLock);
1129         if(g_wow64redir_disable(oldValue))
1130         {
1131                 return true;
1132         }
1133         return false;
1134 }
1135
1136 bool MUtils::OS::wow64fsredir_revert(void *oldValue)
1137 {
1138         QReadLocker readLock(&g_wow64redir_lock);
1139         WOW64FSREDIR_INIT(readLock);
1140         if(g_wow64redir_revert(oldValue))
1141         {
1142                 return true;
1143         }
1144         return false;
1145 }
1146
1147 ///////////////////////////////////////////////////////////////////////////////
1148 // DEBUGGER CHECK
1149 ///////////////////////////////////////////////////////////////////////////////
1150
1151 #if (!(MUTILS_DEBUG))
1152 static __forceinline bool is_debugger_present(void)
1153 {
1154         __try
1155         {
1156                 CloseHandle((HANDLE)((DWORD_PTR)-3));
1157         }
1158         __except(1)
1159         {
1160                 return true;
1161         }
1162
1163         BOOL bHaveDebugger = FALSE;
1164         if(CheckRemoteDebuggerPresent(GetCurrentProcess(), &bHaveDebugger))
1165         {
1166                 if(bHaveDebugger) return true;
1167         }
1168
1169         return IsDebuggerPresent();
1170 }
1171 static __forceinline bool check_debugger_helper(void)
1172 {
1173         if(is_debugger_present())
1174         {
1175                 MUtils::OS::fatal_exit(L"Not a debug build. Please unload debugger and try again!");
1176                 return true;
1177         }
1178         return false;
1179 }
1180 #else
1181 #define check_debugger_helper() (false)
1182 #endif
1183
1184 void MUtils::OS::check_debugger(void)
1185 {
1186         check_debugger_helper();
1187 }
1188
1189 static volatile bool g_debug_check = check_debugger_helper();
1190
1191 ///////////////////////////////////////////////////////////////////////////////
1192 // FATAL EXIT
1193 ///////////////////////////////////////////////////////////////////////////////
1194
1195 static MUtils::Internal::CriticalSection g_fatal_exit_lock;
1196 static volatile bool g_fatal_exit_flag = true;
1197
1198 static DWORD WINAPI fatal_exit_helper(LPVOID lpParameter)
1199 {
1200         MUtils::OS::system_message_err(L"GURU MEDITATION", (LPWSTR) lpParameter);
1201         return 0;
1202 }
1203
1204 void MUtils::OS::fatal_exit(const wchar_t* const errorMessage)
1205 {
1206         g_fatal_exit_lock.enter();
1207
1208         if(!g_fatal_exit_flag)
1209         {
1210                 return; /*prevent recursive invocation*/
1211         }
1212
1213         g_fatal_exit_flag = false;
1214
1215         if(g_main_thread_id != GetCurrentThreadId())
1216         {
1217                 if(HANDLE hThreadMain = OpenThread(THREAD_SUSPEND_RESUME, FALSE, g_main_thread_id))
1218                 {
1219                         SuspendThread(hThreadMain); /*stop main thread*/
1220                 }
1221         }
1222
1223         if(HANDLE hThread = CreateThread(NULL, 0, fatal_exit_helper, (LPVOID) errorMessage, 0, NULL))
1224         {
1225                 WaitForSingleObject(hThread, INFINITE);
1226         }
1227
1228         for(;;)
1229         {
1230                 TerminateProcess(GetCurrentProcess(), 666);
1231         }
1232 }
1233
1234 ///////////////////////////////////////////////////////////////////////////////