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