src/OSSupport_Win32.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2022 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 PSAPI_VERSION 1
  24 #define WIN32_LEAN_AND_MEAN 1
  25 #include <Windows.h>
  26 #include <Psapi.h>
  27 #include <Sensapi.h>
  28 #include <Shellapi.h>
  29 #include <PowrProf.h>
  30 #include <Mmsystem.h>
  31 #include <WinIoCtl.h>
  32 #pragma warning(push)
  33 #pragma warning(disable:4091) //for MSVC2015
  34 #include <ShlObj.h>
  35 #pragma warning(pop)
  36
  37 //CRT
  38 #include <io.h>
  39
  40 //Internal
  41 #include <MUtils/Global.h>
  42 #include <MUtils/OSSupport.h>
  43 #include <MUtils/GUI.h>
  44 #include "Internal.h"
  45 #include "CriticalSection_Win32.h"
  46 #include "Utils_Win32.h"
  47
  48 //Qt
  49 #include <QMap>
  50 #include <QReadWriteLock>
  51 #include <QDir>
  52 #include <QWidget>
  53 #include <QProcess>
  54 #include <QSet>
  55
  56 //Main thread ID
  57 static const DWORD g_main_thread_id = GetCurrentThreadId();
  58
  59 ///////////////////////////////////////////////////////////////////////////////
  60 // SYSTEM MESSAGE
  61 ///////////////////////////////////////////////////////////////////////////////
  62
  63 static const UINT g_msgBoxFlags = MB_TOPMOST | MB_TASKMODAL | MB_SETFOREGROUND;
  64
  65 void MUtils::OS::system_message_nfo(const wchar_t *const title, const wchar_t *const text)
  66 {
  67         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONINFORMATION);
  68 }
  69
  70 void MUtils::OS::system_message_wrn(const wchar_t *const title, const wchar_t *const text)
  71 {
  72         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONWARNING);
  73 }
  74
  75 void MUtils::OS::system_message_err(const wchar_t *const title, const wchar_t *const text)
  76 {
  77         MessageBoxW(NULL, text, title, g_msgBoxFlags | MB_ICONERROR);
  78 }
  79
  80 ///////////////////////////////////////////////////////////////////////////////
  81 // FETCH CLI ARGUMENTS
  82 ///////////////////////////////////////////////////////////////////////////////
  83
  84 static QReadWriteLock                          g_arguments_lock;
  85 static QScopedPointer<MUtils::OS::ArgumentMap> g_arguments_list;
  86
  87 const QStringList MUtils::OS::crack_command_line(const QString &command_line)
  88 {
  89         int nArgs = 0;
  90         LPWSTR *szArglist = CommandLineToArgvW(command_line.isNull() ? GetCommandLineW() : MUTILS_WCHR(command_line), &nArgs);
  91
  92         QStringList command_line_tokens;
  93         if(NULL != szArglist)
  94         {
  95                 for(int i = 0; i < nArgs; i++)
  96                 {
  97                         const QString argStr = MUTILS_QSTR(szArglist[i]).trimmed();
  98                         if(!argStr.isEmpty())
  99                         {
 100                                 command_line_tokens << argStr;
 101                         }
 102                 }
 103                 LocalFree(szArglist);
 104         }
 105
 106         return command_line_tokens;
 107 }
 108
 109 const MUtils::OS::ArgumentMap &MUtils::OS::arguments(void)
 110 {
 111         QReadLocker readLock(&g_arguments_lock);
 112
 113         //Already initialized?
 114         if(!g_arguments_list.isNull())
 115         {
 116                 return (*(g_arguments_list.data()));
 117         }
 118
 119         readLock.unlock();
 120         QWriteLocker writeLock(&g_arguments_lock);
 121
 122         //Still not initialized?
 123         if(!g_arguments_list.isNull())
 124         {
 125                 return (*(g_arguments_list.data()));
 126         }
 127
 128         g_arguments_list.reset(new ArgumentMap());
 129         const QStringList argList = crack_command_line();
 130
 131         if(!argList.isEmpty())
 132         {
 133                 const QString argPrefix = QLatin1String("--");
 134                 const QChar   separator = QLatin1Char('=');
 135
 136                 bool firstToken = true;
 137                 for(QStringList::ConstIterator iter = argList.constBegin(); iter != argList.constEnd(); iter++)
 138                 {
 139                         if(firstToken)
 140                         {
 141                                 firstToken = false;
 142                                 continue; /*skip executable file name*/
 143                         }
 144                         if(iter->startsWith(argPrefix))
 145                         {
 146                                 const QString argData = iter->mid(2).trimmed();
 147                                 if(argData.length() > 0)
 148                                 {
 149                                         const int separatorIndex = argData.indexOf(separator);
 150                                         if(separatorIndex > 0)
 151                                         {
 152                                                 const QString argKey = argData.left(separatorIndex).trimmed();
 153                                                 const QString argVal = argData.mid(separatorIndex + 1).trimmed();
 154                                                 g_arguments_list->insertMulti(argKey.toLower(), argVal);
 155                                         }
 156                                         else
 157                                         {
 158                                                 g_arguments_list->insertMulti(argData.toLower(), QString());
 159                                         }
 160                                 }
 161                         }
 162                 }
 163         }
 164         else if(argList.empty())
 165         {
 166                 qWarning("CommandLineToArgvW() has failed !!!");
 167         }
 168
 169         return (*(g_arguments_list.data()));
 170 }
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173 // COPY FILE
 174 ///////////////////////////////////////////////////////////////////////////////
 175
 176 typedef struct _progress_callback_data_t
 177 {
 178         MUtils::OS::progress_callback_t callback_function;
 179         void *user_data;
 180 }
 181 progress_callback_data_t;
 182
 183 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)
 184 {
 185         if(const progress_callback_data_t *data = (progress_callback_data_t*) lpData)
 186         {
 187                 const double progress = qBound(0.0, double(TotalBytesTransferred.QuadPart) / double(TotalFileSize.QuadPart), 1.0);
 188                 return data->callback_function(progress, data->user_data) ? PROGRESS_CONTINUE : PROGRESS_CANCEL;
 189         }
 190         return PROGRESS_CONTINUE;
 191 }
 192
 193 MUTILS_API bool MUtils::OS::copy_file(const QString &sourcePath, const QString &outputPath, const bool &overwrite, const progress_callback_t callback, void *const userData)
 194 {
 195         progress_callback_data_t callback_data = { callback, userData };
 196         BOOL cancel = FALSE;
 197         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));
 198
 199         if(result == FALSE)
 200         {
 201                 const DWORD errorCode = GetLastError();
 202                 if(errorCode != ERROR_REQUEST_ABORTED)
 203                 {
 204                         qWarning("CopyFile() failed with error code 0x%08X!", errorCode);
 205                 }
 206                 else
 207                 {
 208                         qWarning("CopyFile() operation was abroted by user!");
 209                 }
 210         }
 211
 212         return (result != FALSE);
 213 }
 214
 215 ///////////////////////////////////////////////////////////////////////////////
 216 // GET FILE VERSION
 217 ///////////////////////////////////////////////////////////////////////////////
 218
 219 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)
 220 {
 221         if(!GetFileVersionInfo(MUTILS_WCHR(fileName), 0, size, buffer))
 222         {
 223                 qWarning("GetFileVersionInfo() has failed, file version cannot be determined!");
 224                 return false;
 225         }
 226
 227         VS_FIXEDFILEINFO *verInfo;
 228         UINT verInfoLen;
 229         if(!VerQueryValue(buffer, L"\\", (LPVOID*)(&verInfo), &verInfoLen))
 230         {
 231                 qWarning("VerQueryValue() has failed, file version cannot be determined!");
 232                 return false;
 233         }
 234
 235         if(major) *major = quint16((verInfo->dwFileVersionMS >> 16) & 0x0000FFFF);
 236         if(minor) *minor = quint16((verInfo->dwFileVersionMS)       & 0x0000FFFF);
 237         if(patch) *patch = quint16((verInfo->dwFileVersionLS >> 16) & 0x0000FFFF);
 238         if(build) *build = quint16((verInfo->dwFileVersionLS)       & 0x0000FFFF);
 239
 240         return true;
 241 }
 242
 243 bool MUtils::OS::get_file_version(const QString fileName, quint16 *const major, quint16 *const minor, quint16 *const patch, quint16 *const build)
 244 {
 245         if(major) *major = 0U; if(minor) *minor = 0U;
 246         if(patch) *patch = 0U; if(build) *build = 0U;
 247
 248         const DWORD size = GetFileVersionInfoSize(MUTILS_WCHR(fileName), NULL);
 249         if(size < 1)
 250         {
 251                 qWarning("GetFileVersionInfoSize() has failed, file version cannot be determined!");
 252                 return false;
 253         }
 254
 255         PVOID buffer = _malloca(size);
 256         if(!buffer)
 257         {
 258                 qWarning("Memory allocation has failed!");
 259                 return false;
 260         }
 261
 262         const bool success = get_file_version_helper(fileName, buffer, size, major, minor, patch, build);
 263
 264         _freea(buffer);
 265         return success;
 266 }
 267
 268 ///////////////////////////////////////////////////////////////////////////////
 269 // OS VERSION DETECTION
 270 ///////////////////////////////////////////////////////////////////////////////
 271
 272 static bool g_os_version_initialized = false;
 273 static MUtils::OS::Version::os_version_t g_os_version_info = MUtils::OS::Version::UNKNOWN_OPSYS;
 274 static QReadWriteLock g_os_version_lock;
 275
 276 //Maps marketing names to the actual Windows NT versions
 277 static const struct
 278 {
 279         MUtils::OS::Version::os_version_t version;
 280         const char friendlyName[64];
 281 }
 282 g_os_version_lut[] =
 283 {
 284         { MUtils::OS::Version::WINDOWS_WIN2K, "Windows 2000"                                  }, //2000
 285         { MUtils::OS::Version::WINDOWS_WINXP, "Windows XP or Windows XP Media Center Edition" }, //XP
 286         { MUtils::OS::Version::WINDOWS_XPX64, "Windows Server 2003 or Windows XP x64"         }, //XP_x64
 287         { MUtils::OS::Version::WINDOWS_VISTA, "Windows Vista or Windows Server 2008"          }, //Vista
 288         { MUtils::OS::Version::WINDOWS_WIN70, "Windows 7 or Windows Server 2008 R2"           }, //7
 289         { MUtils::OS::Version::WINDOWS_WIN80, "Windows 8 or Windows Server 2012"              }, //8
 290         { MUtils::OS::Version::WINDOWS_WIN81, "Windows 8.1 or Windows Server 2012 R2"         }, //8.1
 291         { MUtils::OS::Version::WINDOWS_WIN10, "Windows 10 or Windows Server 2016"             }, //10
 292         { MUtils::OS::Version::WINDOWS_WIN11, "Windows 11 or Windows Server 2022"             }, //11
 293         { MUtils::OS::Version::UNKNOWN_OPSYS, "N/A" }
 294 };
 295
 296 //OS version data dtructures
 297 namespace MUtils
 298 {
 299         namespace OS
 300         {
 301                 namespace Version
 302                 {
 303                         //Comparision operators for os_version_t
 304                         bool os_version_t::operator>  (const os_version_t &rhs) const { return (versionMajor > rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor > rhs.versionMinor)) || ((versionMajor == rhs.versionMajor) && (versionMinor == rhs.versionMinor) && (versionBuild >  rhs.versionBuild)); }
 305                         bool os_version_t::operator>= (const os_version_t &rhs) const { return (versionMajor > rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor > rhs.versionMinor)) || ((versionMajor == rhs.versionMajor) && (versionMinor == rhs.versionMinor) && (versionBuild >= rhs.versionBuild)); }
 306                         bool os_version_t::operator<  (const os_version_t &rhs) const { return (versionMajor < rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor < rhs.versionMinor)) || ((versionMajor == rhs.versionMajor) && (versionMinor == rhs.versionMinor) && (versionBuild <  rhs.versionBuild)); }
 307                         bool os_version_t::operator<= (const os_version_t &rhs) const { return (versionMajor < rhs.versionMajor) || ((versionMajor == rhs.versionMajor) && (versionMinor < rhs.versionMinor)) || ((versionMajor == rhs.versionMajor) && (versionMinor == rhs.versionMinor) && (versionBuild <= rhs.versionBuild)); }
 308
 309                         //Known Windows NT versions
 310                         const os_version_t WINDOWS_WIN2K = { OS_WINDOWS,  5U, 0U,     0U, 0U }; // 2000
 311                         const os_version_t WINDOWS_WINXP = { OS_WINDOWS,  5U, 1U,     0U, 0U }; // XP
 312                         const os_version_t WINDOWS_XPX64 = { OS_WINDOWS,  5U, 2U,     0U, 0U }; // XP_x64
 313                         const os_version_t WINDOWS_VISTA = { OS_WINDOWS,  6U, 0U,     0U, 0U }; // Vista
 314                         const os_version_t WINDOWS_WIN70 = { OS_WINDOWS,  6U, 1U,     0U, 0U }; // 7
 315                         const os_version_t WINDOWS_WIN80 = { OS_WINDOWS,  6U, 2U,     0U, 0U }; // 8
 316                         const os_version_t WINDOWS_WIN81 = { OS_WINDOWS,  6U, 3U,     0U, 0U }; // 8.1
 317                         const os_version_t WINDOWS_WIN10 = { OS_WINDOWS, 10U, 0U,     0U, 0U }; // 10
 318                         const os_version_t WINDOWS_WIN11 = { OS_WINDOWS, 10U, 0U, 22000U, 0U }; // 11
 319
 320                         //Unknown OS
 321                         const os_version_t UNKNOWN_OPSYS = { OS_UNKNOWN, 0,  0,     0, 0 };     // N/A
 322                 }
 323         }
 324 }
 325
 326 static inline DWORD SAFE_ADD(const DWORD &a, const DWORD &b, const DWORD &limit = MAXDWORD)
 327 {
 328         return ((a >= limit) || (b >= limit) || ((limit - a) <= b)) ? limit : (a + b);
 329 }
 330
 331 static void initialize_os_version(OSVERSIONINFOEXW *const osInfo)
 332 {
 333         memset(osInfo, 0, sizeof(OSVERSIONINFOEXW));
 334         osInfo->dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
 335 }
 336
 337 static inline DWORD initialize_step_size(const DWORD &limit)
 338 {
 339         DWORD result = 1;
 340         while (result < limit)
 341         {
 342                 result = SAFE_ADD(result, result);
 343         }
 344         return result;
 345 }
 346
 347 #pragma warning(push)
 348 #pragma warning(disable: 4996)
 349
 350 static bool rtl_get_version(OSVERSIONINFOEXW *const osInfo)
 351 {
 352         typedef LONG(__stdcall *RtlGetVersion)(LPOSVERSIONINFOEXW);
 353         if (const HMODULE ntdll = GetModuleHandleW(L"ntdll"))
 354         {
 355                 if (const RtlGetVersion pRtlGetVersion = (RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion"))
 356                 {
 357                         initialize_os_version(osInfo);
 358                         if (pRtlGetVersion(osInfo) == 0)
 359                         {
 360                                 return true;
 361                         }
 362                 }
 363         }
 364
 365         //Fallback
 366         initialize_os_version(osInfo);
 367         return (GetVersionExW((LPOSVERSIONINFOW)osInfo) != FALSE);
 368 }
 369
 370 #pragma warning(pop)
 371
 372 static bool get_real_os_version(unsigned int *const major, unsigned int *const minor, unsigned int *const build, unsigned int *const spack)
 373 {
 374         static const DWORD MAX_VERSION = MAXWORD;
 375         static const DWORD MAX_BUILDNO = MAXINT;
 376         static const DWORD MAX_SRVCPCK = MAXWORD;
 377
 378         //Initialize local variables
 379         *major = *minor = *build = *spack = 0U;
 380         OSVERSIONINFOEXW osvi;
 381         memset(&osvi, 0, sizeof(OSVERSIONINFOEXW));
 382         osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
 383
 384         //Try GetVersionEx() first
 385         if (!rtl_get_version(&osvi))
 386         {
 387                 qWarning("GetVersionEx() has failed, cannot detect Windows version!");
 388                 return false;
 389         }
 390
 391         //Make sure we are running on NT
 392         if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 393         {
 394                 *major = osvi.dwMajorVersion;
 395                 *minor = osvi.dwMinorVersion;
 396                 *build = osvi.dwBuildNumber;
 397                 *spack = osvi.wServicePackMajor;
 398         }
 399         else
 400         {
 401                 qWarning("Not running on Windows NT, unsupported operating system!");
 402                 return false;
 403         }
 404
 405         return true;
 406 }
 407
 408 const MUtils::OS::Version::os_version_t &MUtils::OS::os_version(void)
 409 {
 410         QReadLocker readLock(&g_os_version_lock);
 411
 412         //Already initialized?
 413         if(g_os_version_initialized)
 414         {
 415                 return g_os_version_info;
 416         }
 417
 418         readLock.unlock();
 419         QWriteLocker writeLock(&g_os_version_lock);
 420
 421         //Initialized now?
 422         if(g_os_version_initialized)
 423         {
 424                 return g_os_version_info;
 425         }
 426
 427         //Detect OS version
 428         unsigned int major, minor, build, spack;
 429         if(get_real_os_version(&major, &minor, &build, &spack))
 430         {
 431                 g_os_version_info.type = Version::OS_WINDOWS;
 432                 g_os_version_info.versionMajor = major;
 433                 g_os_version_info.versionMinor = minor;
 434                 g_os_version_info.versionBuild = build;
 435                 g_os_version_info.versionSPack = spack;
 436         }
 437         else
 438         {
 439                 qWarning("Failed to determine the operating system version!");
 440         }
 441
 442         //Completed
 443         g_os_version_initialized = true;
 444         return g_os_version_info;
 445 }
 446
 447 const char *MUtils::OS::os_friendly_name(const MUtils::OS::Version::os_version_t &os_version)
 448 {
 449         const char *friendly_name = NULL;
 450         for (size_t i = 0; g_os_version_lut[i].version.type != MUtils::OS::Version::OS_UNKNOWN; i++)
 451         {
 452                 const MUtils::OS::Version::os_version_t &version = g_os_version_lut[i].version;
 453                 if ((os_version.versionMajor == version.versionMajor) && (os_version.versionMinor == version.versionMinor) && (os_version.versionBuild >= version.versionBuild))
 454                 {
 455                         friendly_name = g_os_version_lut[i].friendlyName;
 456                 }
 457         }
 458
 459         return friendly_name;
 460 }
 461
 462 ///////////////////////////////////////////////////////////////////////////////
 463 // OS ARCHITECTURE DETECTION
 464 ///////////////////////////////////////////////////////////////////////////////
 465
 466 static bool g_os_arch_initialized = false;
 467 static MUtils::OS::os_arch_t g_os_arch = MUtils::OS::os_arch_t(0);
 468 static QReadWriteLock g_os_arch_lock;
 469
 470 static MUtils::OS::os_arch_t detect_os_arch(void)
 471 {
 472 #if (!(defined(_M_X64) || defined(_M_IA64)))
 473         typedef BOOL(WINAPI * IsWow64ProcessFun)(__in HANDLE hProcess, __out PBOOL Wow64Process);
 474         const IsWow64ProcessFun isWow64ProcessPtr = MUtils::Win32Utils::resolve<IsWow64ProcessFun>(QLatin1String("kernel32"), QLatin1String("IsWow64Process"));
 475         if (isWow64ProcessPtr)
 476         {
 477                 BOOL x64flag = FALSE;
 478                 if (isWow64ProcessPtr(GetCurrentProcess(), &x64flag))
 479                 {
 480                         if (x64flag)
 481                         {
 482                                 return MUtils::OS::ARCH_X64;
 483                         }
 484                 }
 485         }
 486         return MUtils::OS::ARCH_X86;
 487 #else
 488         return MUtils::OS::ARCH_X64;
 489 #endif
 490 }
 491
 492 const MUtils::OS::os_arch_t &MUtils::OS::os_architecture(void)
 493 {
 494         QReadLocker readLock(&g_os_arch_lock);
 495
 496         //Already initialized?
 497         if (g_os_arch_initialized)
 498         {
 499                 return g_os_arch;
 500         }
 501
 502         readLock.unlock();
 503         QWriteLocker writeLock(&g_os_arch_lock);
 504
 505         //Initialized now?
 506         if (g_os_arch_initialized)
 507         {
 508                 return g_os_arch;
 509         }
 510
 511         g_os_arch = detect_os_arch();
 512         g_os_arch_initialized = MUTILS_BOOLIFY(g_os_arch);
 513         return g_os_arch;
 514 }
 515
 516 ///////////////////////////////////////////////////////////////////////////////
 517 // WINE DETECTION
 518 ///////////////////////////////////////////////////////////////////////////////
 519
 520 static bool g_wine_deteced = false;
 521 static bool g_wine_initialized = false;
 522 static QReadWriteLock g_wine_lock;
 523
 524 static const bool detect_wine(void)
 525 {
 526         void *const ptr = MUtils::Win32Utils::resolve<void*>(QLatin1String("ntdll"), QLatin1String("wine_get_version"));
 527         return (ptr != NULL);
 528 }
 529
 530 const bool &MUtils::OS::running_on_wine(void)
 531 {
 532         QReadLocker readLock(&g_wine_lock);
 533
 534         //Already initialized?
 535         if(g_wine_initialized)
 536         {
 537                 return g_wine_deteced;
 538         }
 539
 540         readLock.unlock();
 541         QWriteLocker writeLock(&g_wine_lock);
 542
 543         //Initialized now?
 544         if(g_wine_initialized)
 545         {
 546                 return g_wine_deteced;
 547         }
 548
 549         //Try to detect Wine
 550         g_wine_deteced = detect_wine();
 551         g_wine_initialized = true;
 552
 553         return g_wine_deteced;
 554 }
 555
 556 ///////////////////////////////////////////////////////////////////////////////
 557 // KNWON FOLDERS
 558 ///////////////////////////////////////////////////////////////////////////////
 559
 560 static QReadWriteLock                         g_known_folders_lock;
 561 static QScopedPointer<QHash<size_t, QString>> g_known_folders_data;
 562
 563 typedef HRESULT (WINAPI *SHGetKnownFolderPathProc)(const GUID &rfid, DWORD dwFlags, HANDLE hToken, PWSTR *ppszPath);
 564 typedef HRESULT (WINAPI *SHGetFolderPathProc)(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPWSTR pszPath);
 565
 566 static const struct
 567 {
 568         MUtils::OS::known_folder_t id;
 569         INT32 csidl;
 570         GUID known_folder_id;
 571 }
 572 s_known_folders_lut[] =
 573 {
 574         { MUtils::OS::FOLDER_PROFILE_USER,  0x0028, { 0x5E6C858F, 0x0E22, 0x4760, { 0x9A, 0xFE, 0xEA, 0x33, 0x17, 0xB6, 0x71, 0x73 } } },  //CSIDL_PROFILE
 575         { MUtils::OS::FOLDER_PROFILE_PUBL,  0x0000, { 0xDFDF76A2, 0xC82A, 0x4D63, { 0x90, 0x6A, 0x56, 0x44, 0xAC, 0x45, 0x73, 0x85 } } },  //FOLDERID_Public
 576         { MUtils::OS::FOLDER_APPDATA_ROAM,  0x001A, { 0x3EB685DB, 0x65F9, 0x4CF6, { 0xA0, 0x3A, 0xE3, 0xEF, 0x65, 0x72, 0x9F, 0x3D } } },  //CSIDL_APPDATA
 577         { MUtils::OS::FOLDER_APPDATA_LOCA,  0x001C, { 0xF1B32785, 0x6FBA, 0x4FCF, { 0x9D, 0x55, 0x7B, 0x8E, 0x7F, 0x15, 0x70, 0x91 } } },  //CSIDL_LOCAL_APPDATA
 578         { MUtils::OS::FOLDER_DOCS_USER,     0x0005, { 0xFDD39AD0, 0x238F, 0x46AF, { 0xAD, 0xB4, 0x6C, 0x85, 0x48, 0x03, 0x69, 0xC7 } } },  //CSIDL_MYDOCUMENTS
 579         { MUtils::OS::FOLDER_DOCS_PUBL,     0x002E, { 0xED4824AF, 0xDCE4, 0x45A8, { 0x81, 0xE2, 0xFC, 0x79, 0x65, 0x08, 0x36, 0x34 } } },  //CSIDL_COMMON_DOCUMENTS
 580         { MUtils::OS::FOLDER_DESKTOP_USER,  0x0010, { 0xB4BFCC3A, 0xDB2C, 0x424C, { 0xB0, 0x29, 0x7F, 0xE9, 0x9A, 0x87, 0xC6, 0x41 } } },  //CSIDL_DESKTOPDIRECTORY
 581         { MUtils::OS::FOLDER_DESKTOP_PUBL,  0x0019, { 0xC4AA340D, 0xF20F, 0x4863, { 0xAF, 0xEF, 0xF8, 0x7E, 0xF2, 0xE6, 0xBA, 0x25 } } },  //CSIDL_COMMON_DESKTOPDIRECTORY
 582         { MUtils::OS::FOLDER_PICTURES_USER, 0x0027, { 0x33E28130, 0x4E1E, 0x4676, { 0x83, 0x5A, 0x98, 0x39, 0x5C, 0x3B, 0xC3, 0xBB } } },  //CSIDL_MYPICTURES
 583         { MUtils::OS::FOLDER_PICTURES_PUBL, 0x0036, { 0xB6EBFB86, 0x6907, 0x413C, { 0x9A, 0xF7, 0x4F, 0xC2, 0xAB, 0xF0, 0x7C, 0xC5 } } },  //CSIDL_COMMON_PICTURES
 584         { MUtils::OS::FOLDER_MUSIC_USER,    0x000D, { 0x4BD8D571, 0x6D19, 0x48D3, { 0xBE, 0x97, 0x42, 0x22, 0x20, 0x08, 0x0E, 0x43 } } },  //CSIDL_MYMUSIC
 585         { MUtils::OS::FOLDER_MUSIC_PUBL,    0x0035, { 0x3214FAB5, 0x9757, 0x4298, { 0xBB, 0x61, 0x92, 0xA9, 0xDE, 0xAA, 0x44, 0xFF } } },  //CSIDL_COMMON_MUSIC
 586         { MUtils::OS::FOLDER_VIDEO_USER,    0x000E, { 0x18989B1D, 0x99B5, 0x455B, { 0x84, 0x1C, 0xAB, 0x7C, 0x74, 0xE4, 0xDD, 0xFC } } },  //CSIDL_MYVIDEO
 587         { MUtils::OS::FOLDER_VIDEO_PUBL,    0x0037, { 0x2400183A, 0x6185, 0x49FB, { 0xA2, 0xD8, 0x4A, 0x39, 0x2A, 0x60, 0x2B, 0xA3 } } },  //CSIDL_COMMON_VIDEO
 588         { MUtils::OS::FOLDER_PROGRAMS_DEF,  0x0026, { 0x905E63B6, 0xC1BF, 0x494E, { 0xB2, 0x9C, 0x65, 0xB7, 0x32, 0xD3, 0xD2, 0x1A } } },  //CSIDL_PROGRAM_FILES
 589         { MUtils::OS::FOLDER_PROGRAMS_X86,  0x002A, { 0x7C5A40EF, 0xA0FB, 0x4BFC, { 0x87, 0x4A, 0xC0, 0xF2, 0xE0, 0xB9, 0xFA, 0x8E } } },  //CSIDL_PROGRAM_FILESX86
 590         { MUtils::OS::FOLDER_PROGRAMS_X64,  0x0000, { 0x6D809377, 0x6AF0, 0x444B, { 0x89, 0x57, 0xA3, 0x77, 0x3F, 0x02, 0x20, 0x0E } } },  //FOLDERID_ProgramFilesX64 (not supported for 32-bit applications)
 591         { MUtils::OS::FOLDER_SYSROOT,       0x0024, { 0xF38BF404, 0x1D43, 0x42F2, { 0x93, 0x05, 0x67, 0xDE, 0x0B, 0x28, 0xFC, 0x23 } } },  //CSIDL_WINDOWS
 592         { MUtils::OS::FOLDER_SYSTEM_DEF,    0x0025, { 0x1AC14E77, 0x02E7, 0x4E5D, { 0xB7, 0x44, 0x2E, 0xB1, 0xAE, 0x51, 0x98, 0xB7 } } },  //CSIDL_SYSTEM
 593         { MUtils::OS::FOLDER_SYSTEM_X86,    0x0029, { 0xD65231B0, 0xB2F1, 0x4857, { 0xA4, 0xCE, 0xA8, 0xE7, 0xC6, 0xEA, 0x7D, 0x27 } } },  //CSIDL_SYSTEMX86
 594         { static_cast<MUtils::OS::known_folder_t>(0) }
 595 };
 596
 597 static QString known_folder_verify(const wchar_t *const path)
 598 {
 599         const QDir folderPath = QDir(QDir::fromNativeSeparators(MUTILS_QSTR(path)));
 600         if (folderPath.exists())
 601         {
 602                 const QString absolutePath = folderPath.absolutePath();
 603                 const HANDLE handle = CreateFileW(MUTILS_WCHR(QDir::toNativeSeparators(absolutePath)), 0U, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 604                 if (handle != INVALID_HANDLE_VALUE)
 605                 {
 606                         SetHandleInformation(handle, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE);
 607                         return absolutePath;
 608                 }
 609         }
 610
 611         return QString(); /*failed*/
 612 }
 613
 614 static QString known_folder_fallback(const size_t folderId)
 615 {
 616         static const DWORD s_shgfpTypes[3] =
 617         {
 618                 0, /*SHGFP_TYPE_CURRENT*/
 619                 1, /*SHGFP_TYPE_DEFAULT*/
 620                 MAXDWORD
 621         };
 622
 623         static const INT32 s_shgfpFlags[3] =
 624         {
 625                 0x0000, /*No extra flags*/
 626                 0x8000, /*SHGFP_FLAG_CREATE*/
 627                 MAXINT32
 628         };
 629
 630         if (s_known_folders_lut[folderId].csidl)
 631         {
 632                 const SHGetFolderPathProc getFolderPath = MUtils::Win32Utils::resolve<SHGetFolderPathProc>(QLatin1String("shell32"), QLatin1String("SHGetFolderPathW"));
 633                 if (getFolderPath)
 634                 {
 635                         QVector<WCHAR> pathBuffer(MAX_PATH);
 636                         for (size_t i = 0; s_shgfpTypes[i] != MAXDWORD; ++i)
 637                         {
 638                                 for (size_t j = 0; s_shgfpFlags[j] != MAXINT32; ++j)
 639                                 {
 640                                         if (getFolderPath(NULL, s_known_folders_lut[folderId].csidl | s_shgfpFlags[j], NULL, s_shgfpTypes[i], pathBuffer.data()) == S_OK)
 641                                         {
 642                                                 //MessageBoxW(0, pathBuffer.data(), L"SHGetFolderPathW", MB_TOPMOST);
 643                                                 const QString folderPath = known_folder_verify(pathBuffer.data());
 644                                                 if (!folderPath.isEmpty())
 645                                                 {
 646                                                         return folderPath;
 647                                                 }
 648                                         }
 649                                 }
 650                         }
 651                 }
 652         }
 653
 654         return QString(); /*failed!*/
 655 }
 656
 657 static QString known_folder_detect(const size_t folderId)
 658 {
 659         typedef enum
 660         {
 661                 KF_FLAG_DEFAULT      = 0x00000000,
 662                 KF_FLAG_DEFAULT_PATH = 0x00000400,
 663                 KF_FLAG_CREATE       = 0x00008000
 664         }
 665         kf_flag_t;
 666
 667         static const DWORD s_kfFlags[5] =
 668         {
 669                 KF_FLAG_DEFAULT,
 670                 KF_FLAG_CREATE,
 671                 KF_FLAG_DEFAULT_PATH,
 672                 KF_FLAG_DEFAULT_PATH | KF_FLAG_CREATE,
 673                 MAXDWORD
 674         };
 675
 676         const SHGetKnownFolderPathProc getKnownFolderPath = MUtils::Win32Utils::resolve<SHGetKnownFolderPathProc>(QLatin1String("shell32"), QLatin1String("SHGetKnownFolderPath"));
 677         if (getKnownFolderPath)
 678         {
 679                 for (size_t i = 0; s_kfFlags[i] != MAXDWORD; ++i)
 680                 {
 681                         WCHAR* path = NULL;
 682                         if (getKnownFolderPath(s_known_folders_lut[folderId].known_folder_id, s_kfFlags[i], NULL, &path) == S_OK)
 683                         {
 684                                 //MessageBoxW(0, path, L"SHGetKnownFolderPath", MB_TOPMOST);
 685                                 const QString folderPath = known_folder_verify(path);
 686                                 CoTaskMemFree(path);
 687                                 if (!folderPath.isEmpty())
 688                                 {
 689                                         return folderPath;
 690                                 }
 691                         }
 692                 }
 693         }
 694
 695         return known_folder_fallback(folderId); /*fallback!*/
 696 }
 697
 698 static size_t known_folder_decode(const MUtils::OS::known_folder_t folder_id)
 699 {
 700         for (size_t i = 0; s_known_folders_lut[i].id; ++i)
 701         {
 702                 if (s_known_folders_lut[i].id == folder_id)
 703                 {
 704                         return i;
 705                 }
 706         }
 707         qWarning("Invalid 'known' folder was requested!");
 708         return SIZE_MAX;
 709 }
 710
 711 const QString &MUtils::OS::known_folder(const known_folder_t folder_id)
 712 {
 713         //Map to numeric id
 714         const size_t folderId = known_folder_decode(folder_id);
 715         if (folderId == SIZE_MAX)
 716         {
 717                 return Internal::g_empty;
 718         }
 719
 720         //Obtain read lock
 721         QReadLocker readLock(&g_known_folders_lock);
 722
 723         //Already in cache?
 724         if(!g_known_folders_data.isNull())
 725         {
 726                 if(g_known_folders_data->contains(folderId))
 727                 {
 728                         return (*g_known_folders_data)[folderId];
 729                 }
 730         }
 731
 732         //Obtain write lock to initialize
 733         readLock.unlock();
 734         QWriteLocker writeLock(&g_known_folders_lock);
 735
 736         //Still not in cache?
 737         if(!g_known_folders_data.isNull())
 738         {
 739                 if(g_known_folders_data->contains(folderId))
 740                 {
 741                         return (*g_known_folders_data)[folderId];
 742                 }
 743         }
 744
 745         //Initialize on first call
 746         if(g_known_folders_data.isNull())
 747         {
 748                 g_known_folders_data.reset(new QHash<size_t, QString>());
 749         }
 750
 751         //Detect path now!
 752         const QString folderPath = known_folder_detect(folderId);
 753
 754         //Update cache
 755         if (!folderPath.isEmpty())
 756         {
 757                 g_known_folders_data->insert(folderId, folderPath);
 758                 return (*g_known_folders_data)[folderId];
 759         }
 760
 761         return Internal::g_empty;
 762 }
 763
 764 ///////////////////////////////////////////////////////////////////////////////
 765 // CURRENT DATA & TIME
 766 ///////////////////////////////////////////////////////////////////////////////
 767
 768 QDate MUtils::OS::current_date(void)
 769 {
 770         const DWORD MAX_PROC = 1024;
 771         QScopedArrayPointer<DWORD> processes(new DWORD[MAX_PROC]);
 772         DWORD bytesReturned = 0;
 773
 774         if(!EnumProcesses(processes.data(), sizeof(DWORD) * MAX_PROC, &bytesReturned))
 775         {
 776                 return QDate::currentDate();
 777         }
 778
 779         const DWORD procCount = bytesReturned / sizeof(DWORD);
 780         ULARGE_INTEGER lastStartTime;
 781         memset(&lastStartTime, 0, sizeof(ULARGE_INTEGER));
 782
 783         for(DWORD i = 0; i < procCount; i++)
 784         {
 785                 if(HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, processes[i]))
 786                 {
 787                         FILETIME processTime[4];
 788                         if(GetProcessTimes(hProc, &processTime[0], &processTime[1], &processTime[2], &processTime[3]))
 789                         {
 790                                 ULARGE_INTEGER timeCreation;
 791                                 timeCreation.LowPart  = processTime[0].dwLowDateTime;
 792                                 timeCreation.HighPart = processTime[0].dwHighDateTime;
 793                                 if(timeCreation.QuadPart > lastStartTime.QuadPart)
 794                                 {
 795                                         lastStartTime.QuadPart = timeCreation.QuadPart;
 796                                 }
 797                         }
 798                         CloseHandle(hProc);
 799                 }
 800         }
 801
 802         FILETIME lastStartTime_fileTime;
 803         lastStartTime_fileTime.dwHighDateTime = lastStartTime.HighPart;
 804         lastStartTime_fileTime.dwLowDateTime  = lastStartTime.LowPart;
 805
 806         FILETIME lastStartTime_localTime;
 807         if(!FileTimeToLocalFileTime(&lastStartTime_fileTime, &lastStartTime_localTime))
 808         {
 809                 memcpy(&lastStartTime_localTime, &lastStartTime_fileTime, sizeof(FILETIME));
 810         }
 811
 812         SYSTEMTIME lastStartTime_system;
 813         if(!FileTimeToSystemTime(&lastStartTime_localTime, &lastStartTime_system))
 814         {
 815                 memset(&lastStartTime_system, 0, sizeof(SYSTEMTIME));
 816                 lastStartTime_system.wYear = 1970; lastStartTime_system.wMonth = lastStartTime_system.wDay = 1;
 817         }
 818
 819         const QDate currentDate = QDate::currentDate();
 820         const QDate processDate = QDate(lastStartTime_system.wYear, lastStartTime_system.wMonth, lastStartTime_system.wDay);
 821         return (currentDate >= processDate) ? currentDate : processDate;
 822 }
 823
 824 quint64 MUtils::OS::current_file_time(void)
 825 {
 826         FILETIME fileTime;
 827         GetSystemTimeAsFileTime(&fileTime);
 828
 829         ULARGE_INTEGER temp;
 830         temp.HighPart = fileTime.dwHighDateTime;
 831         temp.LowPart = fileTime.dwLowDateTime;
 832
 833         return temp.QuadPart;
 834 }
 835
 836 ///////////////////////////////////////////////////////////////////////////////
 837 // FILE PATH FROM FD
 838 ///////////////////////////////////////////////////////////////////////////////
 839
 840 typedef DWORD(_stdcall *GetPathNameByHandleFun)(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags);
 841
 842 static QString get_file_path_drive_list(void)
 843 {
 844         QString list;
 845         const DWORD len = GetLogicalDriveStringsW(0, NULL);
 846         if (len > 0)
 847         {
 848                 if (wchar_t *const buffer = (wchar_t*) _malloca(sizeof(wchar_t) * len))
 849                 {
 850                         const DWORD ret = GetLogicalDriveStringsW(len, buffer);
 851                         if ((ret > 0) && (ret < len))
 852                         {
 853                                 const wchar_t *ptr = buffer;
 854                                 while (const size_t current_len = wcslen(ptr))
 855                                 {
 856                                         list.append(QChar(*reinterpret_cast<const ushort*>(ptr)));
 857                                         ptr += (current_len + 1);
 858                                 }
 859                         }
 860                         _freea(buffer);
 861                 }
 862         }
 863         return list;
 864 }
 865
 866 static void get_file_path_translate(QString &path)
 867 {
 868         static const DWORD BUFSIZE = 2048;
 869         wchar_t buffer[BUFSIZE], drive[3];
 870
 871         const QString driveList = get_file_path_drive_list();
 872         wcscpy_s(drive, 3, L"?:");
 873         for (const wchar_t *current = MUTILS_WCHR(driveList); *current; current++)
 874         {
 875                 drive[0] = (*current);
 876                 if (QueryDosDeviceW(drive, buffer, MAX_PATH))
 877                 {
 878                         const QString prefix = MUTILS_QSTR(buffer);
 879                         if (path.startsWith(prefix, Qt::CaseInsensitive))
 880                         {
 881                                 path.remove(0, prefix.length()).prepend(QLatin1Char(':')).prepend(QChar(*reinterpret_cast<const ushort*>(current)));
 882                                 break;
 883                         }
 884                 }
 885         }
 886 }
 887
 888 static QString get_file_path_fallback(const HANDLE &hFile)
 889 {
 890         QString filePath;
 891
 892         const HANDLE hFileMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 1, NULL);
 893         if (hFileMap)
 894         {
 895                 void *const pMem = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);
 896                 if (pMem)
 897                 {
 898                         static const size_t BUFFSIZE = 2048;
 899                         wchar_t buffer[BUFFSIZE];
 900                         if (GetMappedFileNameW(GetCurrentProcess(), pMem, buffer, BUFFSIZE) > 0)
 901                         {
 902                                 filePath = MUTILS_QSTR(buffer);
 903                         }
 904                         UnmapViewOfFile(pMem);
 905                 }
 906                 CloseHandle(hFileMap);
 907         }
 908
 909         if (!filePath.isEmpty())
 910         {
 911                 get_file_path_translate(filePath);
 912         }
 913
 914         return filePath;
 915 }
 916
 917 QString MUtils::OS::get_file_path(const int &fd)
 918 {
 919         if (fd >= 0)
 920         {
 921                 const GetPathNameByHandleFun getPathNameByHandleFun = MUtils::Win32Utils::resolve<GetPathNameByHandleFun>(QLatin1String("kernel32"), QLatin1String("GetFinalPathNameByHandleW"));
 922                 if (!getPathNameByHandleFun)
 923                 {
 924                         return get_file_path_fallback((HANDLE)_get_osfhandle(fd));
 925                 }
 926
 927                 const HANDLE handle = (HANDLE) _get_osfhandle(fd);
 928                 const DWORD len = getPathNameByHandleFun(handle, NULL, 0, FILE_NAME_OPENED);
 929                 if (len > 0)
 930                 {
 931                         if (wchar_t *const buffer = (wchar_t*)_malloca(sizeof(wchar_t) * len))
 932                         {
 933                                 const DWORD ret = getPathNameByHandleFun(handle, buffer, len, FILE_NAME_OPENED);
 934                                 if ((ret > 0) && (ret < len))
 935                                 {
 936                                         const QString path(MUTILS_QSTR(buffer));
 937                                         return path.startsWith(QLatin1String("\\\\?\\")) ? path.mid(4) : path;
 938                                 }
 939                                 _freea(buffer);
 940                         }
 941                 }
 942         }
 943
 944         return QString();
 945 }
 946
 947 ///////////////////////////////////////////////////////////////////////////////
 948 // PROCESS ELEVATION
 949 ///////////////////////////////////////////////////////////////////////////////
 950
 951 static bool user_is_admin_helper(void)
 952 {
 953         HANDLE hToken = NULL;
 954         if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 955         {
 956                 return false;
 957         }
 958
 959         DWORD dwSize = 0;
 960         if(!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
 961         {
 962                 if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 963                 {
 964                         CloseHandle(hToken);
 965                         return false;
 966                 }
 967         }
 968
 969         PTOKEN_GROUPS lpGroups = (PTOKEN_GROUPS) malloc(dwSize);
 970         if(!lpGroups)
 971         {
 972                 CloseHandle(hToken);
 973                 return false;
 974         }
 975
 976         if(!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
 977         {
 978                 free(lpGroups);
 979                 CloseHandle(hToken);
 980                 return false;
 981         }
 982
 983         PSID lpSid = NULL; SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
 984         if(!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &lpSid))
 985         {
 986                 free(lpGroups);
 987                 CloseHandle(hToken);
 988                 return false;
 989         }
 990
 991         bool bResult = false;
 992         for(DWORD i = 0; i < lpGroups->GroupCount; i++)
 993         {
 994                 if(EqualSid(lpSid, lpGroups->Groups[i].Sid))
 995                 {
 996                         bResult = true;
 997                         break;
 998                 }
 999         }
1000
1001         FreeSid(lpSid);
1002         free(lpGroups);
1003         CloseHandle(hToken);
1004         return bResult;
1005 }
1006
1007 bool MUtils::OS::is_elevated(bool *bIsUacEnabled)
1008 {
1009         if(bIsUacEnabled)
1010         {
1011                 *bIsUacEnabled = false;
1012         }
1013
1014         bool bIsProcessElevated = false;
1015         HANDLE hToken = NULL;
1016
1017         if(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
1018         {
1019                 TOKEN_ELEVATION_TYPE tokenElevationType;
1020                 DWORD returnLength;
1021                 if(GetTokenInformation(hToken, TokenElevationType, &tokenElevationType, sizeof(TOKEN_ELEVATION_TYPE), &returnLength))
1022                 {
1023                         if(returnLength == sizeof(TOKEN_ELEVATION_TYPE))
1024                         {
1025                                 switch(tokenElevationType)
1026                                 {
1027                                 case TokenElevationTypeDefault:
1028                                         qDebug("Process token elevation type: Default -> UAC is disabled.\n");
1029                                         break;
1030                                 case TokenElevationTypeFull:
1031                                         qWarning("Process token elevation type: Full -> potential security risk!\n");
1032                                         bIsProcessElevated = true;
1033                                         if(bIsUacEnabled) *bIsUacEnabled = true;
1034                                         break;
1035                                 case TokenElevationTypeLimited:
1036                                         qDebug("Process token elevation type: Limited -> not elevated.\n");
1037                                         if(bIsUacEnabled) *bIsUacEnabled = true;
1038                                         break;
1039                                 default:
1040                                         qWarning("Unknown tokenElevationType value: %d", tokenElevationType);
1041                                         break;
1042                                 }
1043                         }
1044                         else
1045                         {
1046                                 qWarning("GetTokenInformation() return an unexpected size!");
1047                         }
1048                 }
1049                 CloseHandle(hToken);
1050         }
1051         else
1052         {
1053                 qWarning("Failed to open process token!");
1054         }
1055
1056         return bIsProcessElevated;
1057 }
1058
1059 bool MUtils::OS::user_is_admin(void)
1060 {
1061         bool isAdmin = false;
1062
1063         //Check for process elevation and UAC support first!
1064         if(MUtils::OS::is_elevated(&isAdmin))
1065         {
1066                 qWarning("Process is elevated -> user is admin!");
1067                 return true;
1068         }
1069
1070         //If not elevated and UAC is not available -> user must be in admin group!
1071         if(!isAdmin)
1072         {
1073                 qDebug("UAC is disabled/unavailable -> checking for Administrators group");
1074                 isAdmin = user_is_admin_helper();
1075         }
1076
1077         return isAdmin;
1078 }
1079
1080 ///////////////////////////////////////////////////////////////////////////////
1081 // NETWORK STATE
1082 ///////////////////////////////////////////////////////////////////////////////
1083
1084 int MUtils::OS::network_status(void)
1085 {
1086         DWORD dwFlags;
1087         const BOOL ret = IsNetworkAlive(&dwFlags);
1088         if(GetLastError() == 0)
1089         {
1090                 return (ret != FALSE) ? NETWORK_TYPE_YES : NETWORK_TYPE_NON;
1091         }
1092         return NETWORK_TYPE_ERR;
1093 }
1094
1095 ///////////////////////////////////////////////////////////////////////////////
1096 // MESSAGE HANDLER
1097 ///////////////////////////////////////////////////////////////////////////////
1098
1099 bool MUtils::OS::handle_os_message(const void *const message, long *result)
1100 {
1101         const MSG *const msg = reinterpret_cast<const MSG*>(message);
1102
1103         switch(msg->message)
1104         {
1105         case WM_QUERYENDSESSION:
1106                 qWarning("WM_QUERYENDSESSION message received!");
1107                 *result = MUtils::GUI::broadcast(MUtils::GUI::USER_EVENT_QUERYENDSESSION, false) ? TRUE : FALSE;
1108                 return true;
1109         case WM_ENDSESSION:
1110                 qWarning("WM_ENDSESSION message received!");
1111                 if(msg->wParam == TRUE)
1112                 {
1113                         MUtils::GUI::broadcast(MUtils::GUI::USER_EVENT_ENDSESSION, false);
1114                         MUtils::GUI::force_quit();
1115                         exit(1);
1116                 }
1117                 *result = 0;
1118                 return true;
1119         default:
1120                 /*ignore this message and let Qt handle it*/
1121                 return false;
1122         }
1123 }
1124
1125 ///////////////////////////////////////////////////////////////////////////////
1126 // SLEEP
1127 ///////////////////////////////////////////////////////////////////////////////
1128
1129 void MUtils::OS::sleep_ms(const size_t &duration)
1130 {
1131         Sleep((DWORD) duration);
1132 }
1133
1134 ///////////////////////////////////////////////////////////////////////////////
1135 // EXECUTABLE CHECK
1136 ///////////////////////////////////////////////////////////////////////////////
1137
1138 static int g_library_as_image_resource_supported = -1;
1139 static QReadWriteLock g_library_as_image_resource_supported_lock;
1140
1141 static bool library_as_image_resource_supported()
1142 {
1143         QReadLocker readLocker(&g_library_as_image_resource_supported_lock);
1144         if (g_library_as_image_resource_supported >= 0)
1145         {
1146                 return (g_library_as_image_resource_supported > 0);
1147         }
1148
1149         readLocker.unlock();
1150         QWriteLocker writeLocker(&g_library_as_image_resource_supported_lock);
1151
1152         if (g_library_as_image_resource_supported < 0)
1153         {
1154                 g_library_as_image_resource_supported = 0;
1155                 OSVERSIONINFOEXW osvi;
1156                 if (rtl_get_version(&osvi))
1157                 {
1158                         if ((osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) && (osvi.dwMajorVersion >= 6U))
1159                         {
1160                                 g_library_as_image_resource_supported = 1;
1161                         }
1162                 }
1163         }
1164
1165         return (g_library_as_image_resource_supported > 0);
1166 }
1167
1168 bool MUtils::OS::is_executable_file(const QString &path)
1169 {
1170         DWORD binaryType;
1171         if(GetBinaryType(MUTILS_WCHR(QDir::toNativeSeparators(path)), &binaryType))
1172         {
1173                 return ((binaryType == SCS_32BIT_BINARY) || (binaryType == SCS_64BIT_BINARY));
1174         }
1175
1176         const DWORD errorCode = GetLastError();
1177         qWarning("GetBinaryType() failed with error: 0x%08X", errorCode);
1178         return false;
1179 }
1180
1181 bool MUtils::OS::is_library_file(const QString &path)
1182 {
1183         const DWORD flags = library_as_image_resource_supported() ? (LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE) : (LOAD_LIBRARY_AS_DATAFILE | DONT_RESOLVE_DLL_REFERENCES);
1184         if (const HMODULE hMod = LoadLibraryEx(MUTILS_WCHR(QDir::toNativeSeparators(path)), NULL, flags))
1185         {
1186                 FreeLibrary(hMod);
1187                 return true;
1188         }
1189
1190         const DWORD errorCode = GetLastError();
1191         qWarning("LoadLibraryEx() failed with error: 0x%08X", errorCode);
1192         return false;
1193 }
1194
1195 ///////////////////////////////////////////////////////////////////////////////
1196 // HIBERNATION / SHUTDOWN
1197 ///////////////////////////////////////////////////////////////////////////////
1198
1199 bool MUtils::OS::is_hibernation_supported(void)
1200 {
1201         bool hibernationSupported = false;
1202
1203         SYSTEM_POWER_CAPABILITIES pwrCaps;
1204         SecureZeroMemory(&pwrCaps, sizeof(SYSTEM_POWER_CAPABILITIES));
1205
1206         if(GetPwrCapabilities(&pwrCaps))
1207         {
1208                 hibernationSupported = pwrCaps.SystemS4 && pwrCaps.HiberFilePresent;
1209         }
1210
1211         return hibernationSupported;
1212 }
1213
1214 bool MUtils::OS::shutdown_computer(const QString &message, const unsigned long timeout, const bool forceShutdown, const bool hibernate)
1215 {
1216         HANDLE hToken = NULL;
1217
1218         if(OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
1219         {
1220                 TOKEN_PRIVILEGES privileges;
1221                 memset(&privileges, 0, sizeof(TOKEN_PRIVILEGES));
1222                 privileges.PrivilegeCount = 1;
1223                 privileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
1224
1225                 if(LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &privileges.Privileges[0].Luid))
1226                 {
1227                         if(AdjustTokenPrivileges(hToken, FALSE, &privileges, NULL, NULL, NULL))
1228                         {
1229                                 if(hibernate)
1230                                 {
1231                                         if(SetSuspendState(TRUE, TRUE, TRUE))
1232                                         {
1233                                                 return true;
1234                                         }
1235                                 }
1236                                 const DWORD reason = SHTDN_REASON_MAJOR_APPLICATION | SHTDN_REASON_FLAG_PLANNED;
1237                                 return InitiateSystemShutdownEx(NULL, const_cast<wchar_t*>(MUTILS_WCHR(message)), timeout, forceShutdown ? TRUE : FALSE, FALSE, reason);
1238                         }
1239                 }
1240         }
1241
1242         return false;
1243 }
1244
1245 ///////////////////////////////////////////////////////////////////////////////
1246 // FREE DISKSPACE
1247 ///////////////////////////////////////////////////////////////////////////////
1248
1249 bool MUtils::OS::free_diskspace(const QString &path, quint64 &freeSpace)
1250 {
1251         ULARGE_INTEGER freeBytesAvailable, totalNumberOfBytes, totalNumberOfFreeBytes;
1252         if(GetDiskFreeSpaceExW(reinterpret_cast<const wchar_t*>(QDir::toNativeSeparators(path).utf16()), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes))
1253         {
1254                 freeSpace = freeBytesAvailable.QuadPart;
1255                 return true;;
1256         }
1257
1258         freeSpace = static_cast<quint64>(-1);
1259         return false;
1260 }
1261
1262 ///////////////////////////////////////////////////////////////////////////////
1263 // DRIVE TYPE
1264 ///////////////////////////////////////////////////////////////////////////////
1265
1266 static wchar_t get_drive_letter(const QString &path)
1267 {
1268         QString nativePath = QDir::toNativeSeparators(path);
1269         while (nativePath.startsWith("\\\\?\\") || nativePath.startsWith("\\\\.\\"))
1270         {
1271                 nativePath = QDir::toNativeSeparators(nativePath.mid(4));
1272         }
1273         if ((path.length() > 1) && (path[1] == QLatin1Char(':')))
1274         {
1275                 const wchar_t letter = static_cast<wchar_t>(path[0].unicode());
1276                 if (((letter >= 'A') && (letter <= 'Z')) || ((letter >= 'a') && (letter <= 'z')))
1277                 {
1278                         return towupper(letter);
1279                 }
1280         }
1281         return L'\0'; /*invalid path spec*/
1282 }
1283
1284 static QSet<DWORD> get_physical_drive_ids(const wchar_t drive_letter)
1285 {
1286         QSet<DWORD> physical_drives;
1287         wchar_t driveName[8];
1288         _snwprintf_s(driveName, 8, _TRUNCATE, L"\\\\.\\%c:", drive_letter);
1289         const HANDLE hDrive = CreateFileW(driveName, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1290         if (hDrive && (hDrive != INVALID_HANDLE_VALUE))
1291         {
1292                 const size_t BUFF_SIZE = sizeof(VOLUME_DISK_EXTENTS) + (32U * sizeof(DISK_EXTENT));
1293                 VOLUME_DISK_EXTENTS *const diskExtents = (VOLUME_DISK_EXTENTS*)_malloca(BUFF_SIZE);
1294                 DWORD dwSize;
1295                 if (DeviceIoControl(hDrive, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, (LPVOID)diskExtents, (DWORD)BUFF_SIZE, (LPDWORD)&dwSize, NULL))
1296                 {
1297                         for (DWORD index = 0U; index < diskExtents->NumberOfDiskExtents; ++index)
1298                         {
1299                                 physical_drives.insert(diskExtents->Extents[index].DiskNumber);
1300                         }
1301                 }
1302                 _freea(diskExtents);
1303                 CloseHandle(hDrive);
1304         }
1305         return physical_drives;
1306 }
1307
1308 static bool incurs_seek_penalty(const DWORD device_id)
1309 {
1310         wchar_t driveName[24];
1311         _snwprintf_s(driveName, 24, _TRUNCATE, L"\\\\?\\PhysicalDrive%u", device_id);
1312         const HANDLE hDevice = CreateFileW(driveName, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1313         bool seeking_penalty = true;
1314         if (hDevice && (hDevice != INVALID_HANDLE_VALUE))
1315         {
1316                 STORAGE_PROPERTY_QUERY spq;
1317                 DEVICE_SEEK_PENALTY_DESCRIPTOR dspd;
1318                 memset(&spq, 0, sizeof(STORAGE_PROPERTY_QUERY));
1319                 spq.PropertyId = (STORAGE_PROPERTY_ID)StorageDeviceSeekPenaltyProperty;
1320                 spq.QueryType = PropertyStandardQuery;
1321                 DWORD dwSize;
1322                 if (DeviceIoControl(hDevice, IOCTL_STORAGE_QUERY_PROPERTY, (LPVOID)&spq, (DWORD)sizeof(spq), (LPVOID)&dspd, (DWORD)sizeof(dspd), (LPDWORD)&dwSize, NULL))
1323                 {
1324                         seeking_penalty = dspd.IncursSeekPenalty;
1325                 }
1326                 CloseHandle(hDevice);
1327         }
1328         return seeking_penalty;
1329 }
1330
1331 static bool is_fast_seeking_drive(const wchar_t drive_letter)
1332 {
1333         bool fast_seeking = false;
1334         const QSet<DWORD> physical_drive_ids = get_physical_drive_ids(drive_letter);
1335         if (!physical_drive_ids.empty())
1336         {
1337                 fast_seeking = true;
1338                 for (QSet<DWORD>::const_iterator iter = physical_drive_ids.constBegin(); iter != physical_drive_ids.constEnd(); ++iter)
1339                 {
1340                         fast_seeking = fast_seeking && (!incurs_seek_penalty(*iter));
1341                 }
1342         }
1343         return fast_seeking;
1344 }
1345
1346 MUtils::OS::drive_type_t MUtils::OS::get_drive_type(const QString &path, bool *fast_seeking)
1347 {
1348         drive_type_t driveType = DRIVE_TYPE_ERR;
1349         const wchar_t driveLetter = get_drive_letter(path);
1350         if (driveLetter)
1351         {
1352                 wchar_t driveName[8];
1353                 _snwprintf_s(driveName, 8, _TRUNCATE, L"\\\\.\\%c:\\", driveLetter);
1354                 switch (GetDriveTypeW(driveName))
1355                 {
1356                         case DRIVE_REMOVABLE: driveType = DRIVE_TYPE_FDD; break;
1357                         case DRIVE_FIXED:     driveType = DRIVE_TYPE_HDD; break;
1358                         case DRIVE_REMOTE:    driveType = DRIVE_TYPE_NET; break;
1359                         case DRIVE_CDROM:     driveType = DRIVE_TYPE_OPT; break;
1360                         case DRIVE_RAMDISK:   driveType = DRIVE_TYPE_RAM; break;
1361                 }
1362         }
1363         if (fast_seeking)
1364         {
1365                 if (driveType == DRIVE_TYPE_HDD)
1366                 {
1367                         *fast_seeking = is_fast_seeking_drive(driveLetter);
1368                 }
1369                 else
1370                 {
1371                         *fast_seeking = (driveType == DRIVE_TYPE_RAM);
1372                 }
1373         }
1374         return driveType;
1375 }
1376
1377 ///////////////////////////////////////////////////////////////////////////////
1378 // SHELL OPEN
1379 ///////////////////////////////////////////////////////////////////////////////
1380
1381 bool MUtils::OS::shell_open(const QWidget *parent, const QString &url, const QString &parameters, const QString &directory, const bool explore)
1382 {
1383         return ((int) ShellExecuteW((parent ? reinterpret_cast<HWND>(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;
1384 }
1385
1386 bool MUtils::OS::shell_open(const QWidget *parent, const QString &url, const bool explore)
1387 {
1388         return shell_open(parent, url, QString(), QString(), explore);
1389 }
1390
1391 ///////////////////////////////////////////////////////////////////////////////
1392 // OPEN MEDIA FILE
1393 ///////////////////////////////////////////////////////////////////////////////
1394
1395 bool MUtils::OS::open_media_file(const QString &mediaFilePath)
1396 {
1397         const static wchar_t *registryPrefix[2] = { L"SOFTWARE\\", L"SOFTWARE\\Wow6432Node\\" };
1398         const static wchar_t *registryKeys[3] =
1399         {
1400                 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{97D341C8-B0D1-4E4A-A49A-C30B52F168E9}",
1401                 L"Microsoft\\Windows\\CurrentVersion\\Uninstall\\{DB9E4EAB-2717-499F-8D56-4CC8A644AB60}",
1402                 L"foobar2000"
1403         };
1404         const static wchar_t *appNames[4] = { L"smplayer_portable.exe", L"smplayer.exe", L"MPUI.exe", L"foobar2000.exe" };
1405         const static wchar_t *valueNames[2] = { L"InstallLocation", L"InstallDir" };
1406
1407         for(size_t i = 0; i < 3; i++)
1408         {
1409                 for(size_t j = 0; j < 2; j++)
1410                 {
1411                         QString mplayerPath;
1412                         HKEY registryKeyHandle = NULL;
1413
1414                         const QString currentKey = MUTILS_QSTR(registryPrefix[j]).append(MUTILS_QSTR(registryKeys[i]));
1415                         if(RegOpenKeyExW(HKEY_LOCAL_MACHINE, MUTILS_WCHR(currentKey), 0, KEY_READ, &registryKeyHandle) == ERROR_SUCCESS)
1416                         {
1417                                 for(size_t k = 0; k < 2; k++)
1418                                 {
1419                                         wchar_t Buffer[4096];
1420                                         DWORD BuffSize = sizeof(wchar_t*) * 4096;
1421                                         DWORD DataType = REG_NONE;
1422                                         if(RegQueryValueExW(registryKeyHandle, valueNames[k], 0, &DataType, reinterpret_cast<BYTE*>(Buffer), &BuffSize) == ERROR_SUCCESS)
1423                                         {
1424                                                 if((DataType == REG_SZ) || (DataType == REG_EXPAND_SZ) || (DataType == REG_LINK))
1425                                                 {
1426                                                         mplayerPath = MUTILS_QSTR(Buffer);
1427                                                         break;
1428                                                 }
1429                                         }
1430                                 }
1431                                 RegCloseKey(registryKeyHandle);
1432                         }
1433
1434                         if(!mplayerPath.isEmpty())
1435                         {
1436                                 QDir mplayerDir(mplayerPath);
1437                                 if(mplayerDir.exists())
1438                                 {
1439                                         for(size_t k = 0; k < 4; k++)
1440                                         {
1441                                                 if(mplayerDir.exists(MUTILS_QSTR(appNames[k])))
1442                                                 {
1443                                                         qDebug("Player found at:\n%s\n", MUTILS_UTF8(mplayerDir.absoluteFilePath(MUTILS_QSTR(appNames[k]))));
1444                                                         QProcess::startDetached(mplayerDir.absoluteFilePath(MUTILS_QSTR(appNames[k])), QStringList() << QDir::toNativeSeparators(mediaFilePath));
1445                                                         return true;
1446                                                 }
1447                                         }
1448                                 }
1449                         }
1450                 }
1451         }
1452         return false;
1453 }
1454
1455 ///////////////////////////////////////////////////////////////////////////////
1456 // DEBUGGER CHECK
1457 ///////////////////////////////////////////////////////////////////////////////
1458
1459 static bool change_process_priority_helper(const HANDLE hProcess, const int priority)
1460 {
1461         bool ok = false;
1462
1463         switch(qBound(-2, priority, 2))
1464         {
1465         case 2:
1466                 ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
1467                 break;
1468         case 1:
1469                 if(!(ok = (SetPriorityClass(hProcess, ABOVE_NORMAL_PRIORITY_CLASS) == TRUE)))
1470                 {
1471                         ok = (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS) == TRUE);
1472                 }
1473                 break;
1474         case 0:
1475                 ok = (SetPriorityClass(hProcess, NORMAL_PRIORITY_CLASS) == TRUE);
1476                 break;
1477         case -1:
1478                 if(!(ok = (SetPriorityClass(hProcess, BELOW_NORMAL_PRIORITY_CLASS) == TRUE)))
1479                 {
1480                         ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
1481                 }
1482                 break;
1483         case -2:
1484                 ok = (SetPriorityClass(hProcess, IDLE_PRIORITY_CLASS) == TRUE);
1485                 break;
1486         }
1487
1488         return ok;
1489 }
1490
1491 bool MUtils::OS::change_process_priority(const int priority)
1492 {
1493         return change_process_priority_helper(GetCurrentProcess(), priority);
1494 }
1495
1496 bool MUtils::OS::change_process_priority(const QProcess *proc, const int priority)
1497 {
1498         if(Q_PID qPid = proc->pid())
1499         {
1500                 return change_process_priority_helper(qPid->hProcess, priority);
1501         }
1502         else
1503         {
1504                 return false;
1505         }
1506 }
1507
1508 ///////////////////////////////////////////////////////////////////////////////
1509 // PROCESS ID
1510 ///////////////////////////////////////////////////////////////////////////////
1511
1512 quint32 MUtils::OS::process_id(void)
1513 {
1514         return GetCurrentProcessId();
1515 }
1516
1517 quint32 MUtils::OS::process_id(const QProcess *const proc)
1518 {
1519         PROCESS_INFORMATION *procInf = proc->pid();
1520         return (procInf) ? procInf->dwProcessId : 0;
1521 }
1522
1523 quint32 MUtils::OS::thread_id(void)
1524 {
1525         return GetCurrentThreadId();
1526 }
1527
1528 quint32 MUtils::OS::thread_id(const QProcess *const proc)
1529 {
1530         PROCESS_INFORMATION *procInf = proc->pid();
1531         return (procInf) ? procInf->dwThreadId : 0;
1532 }
1533
1534 ///////////////////////////////////////////////////////////////////////////////
1535 // PROCESS SUSPEND/RESUME
1536 ///////////////////////////////////////////////////////////////////////////////
1537
1538 bool MUtils::OS::suspend_process(const QProcess *proc, const bool suspend)
1539 {
1540         if(Q_PID pid = proc->pid())
1541         {
1542                 if(suspend)
1543                 {
1544                         return (SuspendThread(pid->hThread) != ((DWORD) -1));
1545                 }
1546                 else
1547                 {
1548                         return (ResumeThread(pid->hThread)  != ((DWORD) -1));
1549                 }
1550         }
1551         else
1552         {
1553                 return false;
1554         }
1555 }
1556
1557 ///////////////////////////////////////////////////////////////////////////////
1558 // SYSTEM TIMER
1559 ///////////////////////////////////////////////////////////////////////////////
1560
1561 bool MUtils::OS::setup_timer_resolution(const quint32 &interval)
1562 {
1563         return timeBeginPeriod(interval) == TIMERR_NOERROR;
1564 }
1565
1566 bool MUtils::OS::reset_timer_resolution(const quint32 &interval)
1567 {
1568         return timeEndPeriod(interval) == TIMERR_NOERROR;
1569 }
1570
1571 ///////////////////////////////////////////////////////////////////////////////
1572 // SET FILE TIME
1573 ///////////////////////////////////////////////////////////////////////////////
1574
1575 static QScopedPointer<QDateTime> s_epoch;
1576 static QReadWriteLock            s_epochLock;
1577
1578 static const QDateTime *get_epoch(void)
1579 {
1580         QReadLocker rdLock(&s_epochLock);
1581
1582         if (s_epoch.isNull())
1583         {
1584                 rdLock.unlock();
1585                 QWriteLocker wrLock(&s_epochLock);
1586                 if (s_epoch.isNull())
1587                 {
1588                         s_epoch.reset(new QDateTime(QDate(1601, 1, 1), QTime(0, 0, 0, 0), Qt::UTC));
1589                 }
1590                 wrLock.unlock();
1591                 rdLock.relock();
1592         }
1593
1594         return s_epoch.data();
1595 }
1596
1597 static FILETIME *qt_time_to_file_time(FILETIME *const fileTime, const QDateTime &dateTime)
1598 {
1599         memset(fileTime, 0, sizeof(FILETIME));
1600
1601         if (const QDateTime *const epoch = get_epoch())
1602         {
1603                 const qint64 msecs = epoch->msecsTo(dateTime);
1604                 if (msecs > 0)
1605                 {
1606                         const quint64 ticks = 10000U * quint64(msecs);
1607                         fileTime->dwHighDateTime = ((ticks >> 32) & 0xFFFFFFFF);
1608                         fileTime->dwLowDateTime = (ticks & 0xFFFFFFFF);
1609                         return fileTime;
1610                 }
1611         }
1612
1613         return NULL;
1614 }
1615
1616 static bool set_file_time(const HANDLE hFile, const QDateTime &created, const QDateTime &lastMod, const QDateTime &lastAcc)
1617 {
1618         FILETIME ftCreated, ftLastMod, ftLastAcc;
1619
1620         FILETIME *const pCreated = created.isValid() ? qt_time_to_file_time(&ftCreated, created) : NULL;
1621         FILETIME *const pLastMod = lastMod.isValid() ? qt_time_to_file_time(&ftLastMod, lastMod) : NULL;
1622         FILETIME *const pLastAcc = lastAcc.isValid() ? qt_time_to_file_time(&ftLastAcc, lastAcc) : NULL;
1623
1624         if (pCreated || pLastMod || pLastAcc)
1625         {
1626                 return (SetFileTime(hFile, pCreated, pLastAcc, pLastMod) != FALSE);
1627         }
1628
1629         return false;
1630 }
1631
1632 bool MUtils::OS::set_file_time(const QFile &file, const QDateTime &created, const QDateTime &lastMod, const QDateTime &lastAcc)
1633 {
1634         const int fd = file.handle();
1635         if (fd >= 0)
1636         {
1637                 return set_file_time((HANDLE)_get_osfhandle(fd), created, lastMod, lastAcc);
1638         }
1639         return false;
1640 }
1641
1642 bool MUtils::OS::set_file_time(const QString &path, const QDateTime &created, const QDateTime &lastMod, const QDateTime &lastAcc)
1643 {
1644         const HANDLE hFile = CreateFileW(MUTILS_WCHR(path), FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
1645         bool okay = false;
1646         if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
1647         {
1648                 okay = set_file_time(hFile, created, lastMod, lastAcc);
1649                 CloseHandle(hFile);
1650         }
1651         return okay;
1652 }
1653
1654 ///////////////////////////////////////////////////////////////////////////////
1655 // CHECK KEY STATE
1656 ///////////////////////////////////////////////////////////////////////////////
1657
1658 bool MUtils::OS::check_key_state_esc(void)
1659 {
1660         return (GetAsyncKeyState(VK_ESCAPE) & 0x0001) != 0;
1661 }
1662
1663 ///////////////////////////////////////////////////////////////////////////////
1664 // SHELL CHANGE NOTIFICATION
1665 ///////////////////////////////////////////////////////////////////////////////
1666
1667 void MUtils::OS::shell_change_notification(void)
1668 {
1669         SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
1670 }
1671
1672 ///////////////////////////////////////////////////////////////////////////////
1673 // WOW64 REDIRECTION
1674 ///////////////////////////////////////////////////////////////////////////////
1675
1676 typedef BOOL (_stdcall *Wow64DisableWow64FsRedirectionFun)(PVOID *OldValue);
1677 typedef BOOL (_stdcall *Wow64RevertWow64FsRedirectionFun) (PVOID  OldValue);
1678
1679 bool MUtils::OS::wow64fsredir_disable(uintptr_t &oldValue)
1680 {
1681         oldValue = reinterpret_cast<uintptr_t>(nullptr);
1682         const Wow64DisableWow64FsRedirectionFun wow64redir_disable = MUtils::Win32Utils::resolve<Wow64DisableWow64FsRedirectionFun>(QLatin1String("kernel32"), QLatin1String("Wow64DisableWow64FsRedirection"));
1683         if(wow64redir_disable)
1684         {
1685                 PVOID temp = NULL;
1686                 if (wow64redir_disable(&temp))
1687                 {
1688                         oldValue = reinterpret_cast<uintptr_t>(temp);
1689                         return true;
1690                 }
1691         }
1692         return false;
1693 }
1694
1695 bool MUtils::OS::wow64fsredir_revert(const uintptr_t oldValue)
1696 {
1697         const Wow64RevertWow64FsRedirectionFun wow64redir_disable = MUtils::Win32Utils::resolve<Wow64RevertWow64FsRedirectionFun>(QLatin1String("kernel32"), QLatin1String("Wow64RevertWow64FsRedirection"));
1698         if (wow64redir_disable)
1699         {
1700                 if (wow64redir_disable(reinterpret_cast<PVOID>(oldValue)))
1701                 {
1702                         return true;
1703                 }
1704         }
1705         return false;
1706 }
1707
1708 ///////////////////////////////////////////////////////////////////////////////
1709 // DEBUGGER CHECK
1710 ///////////////////////////////////////////////////////////////////////////////
1711
1712 QString MUtils::OS::get_envvar(const QString &name)
1713 {
1714         wchar_t *buffer = NULL;
1715         size_t requiredSize = 0, buffSize = 0;
1716         QString result;
1717
1718         forever
1719         {
1720                 //Adjust the buffer size as required first!
1721                 if (buffSize < requiredSize)
1722                 {
1723                         if (buffer)
1724                         {
1725                                 _freea(buffer);
1726                         }
1727                         if (!(buffer = (wchar_t*)_malloca(sizeof(wchar_t) * requiredSize)))
1728                         {
1729                                 break; /*out of memory error!*/
1730                         }
1731                         buffSize = requiredSize;
1732                 }
1733
1734                 //Try to fetch the environment variable now
1735                 const errno_t error = _wgetenv_s(&requiredSize, buffer, buffSize, MUTILS_WCHR(name));
1736                 if(!error)
1737                 {
1738                         if (requiredSize > 0)
1739                         {
1740                                 result = MUTILS_QSTR(buffer);
1741                         }
1742                         break; /*done*/
1743                 }
1744                 else if (error != ERANGE)
1745                 {
1746                         break; /*somethging else went wrong!*/
1747                 }
1748         }
1749
1750         if (buffer)
1751         {
1752                 _freea(buffer);
1753                 buffSize = 0;
1754                 buffer = NULL;
1755         }
1756
1757         return result;
1758 }
1759
1760 bool MUtils::OS::set_envvar(const QString &name, const QString &value)
1761 {
1762         if (!_wputenv_s(MUTILS_WCHR(name), MUTILS_WCHR(value)))
1763         {
1764                 return true;
1765         }
1766         return false;
1767 }
1768
1769 ///////////////////////////////////////////////////////////////////////////////
1770 // NULL DEVICE
1771 ///////////////////////////////////////////////////////////////////////////////
1772
1773 static const QLatin1String NULL_DEVICE("NUL");
1774
1775 const QLatin1String &MUtils::OS::null_device(void)
1776 {
1777         return NULL_DEVICE;
1778 }
1779
1780 ///////////////////////////////////////////////////////////////////////////////
1781 // DEBUGGER CHECK
1782 ///////////////////////////////////////////////////////////////////////////////
1783
1784 #if 0//(!(MUTILS_DEBUG))
1785 static __forceinline bool is_debugger_present(void)
1786 {
1787         __try
1788         {
1789                 CloseHandle((HANDLE)((DWORD_PTR)-3));
1790         }
1791         __except(1)
1792         {
1793                 return true;
1794         }
1795
1796         BOOL bHaveDebugger = FALSE;
1797         if(CheckRemoteDebuggerPresent(GetCurrentProcess(), &bHaveDebugger))
1798         {
1799                 if(bHaveDebugger) return true;
1800         }
1801
1802         return IsDebuggerPresent();
1803 }
1804 static __forceinline bool check_debugger_helper(void)
1805 {
1806         if(is_debugger_present())
1807         {
1808                 MUtils::OS::fatal_exit(L"Not a debug build. Please unload debugger and try again!");
1809                 return true;
1810         }
1811         return false;
1812 }
1813 #else
1814 #define check_debugger_helper() (false)
1815 #endif
1816
1817 void MUtils::OS::check_debugger(void)
1818 {
1819         check_debugger_helper();
1820 }
1821
1822 static volatile bool g_debug_check = check_debugger_helper();
1823
1824 ///////////////////////////////////////////////////////////////////////////////
1825 // FATAL EXIT
1826 ///////////////////////////////////////////////////////////////////////////////
1827
1828 static MUtils::Internal::CriticalSection g_fatal_exit_lock;
1829 static QAtomicInt g_fatal_exit_flag;
1830
1831 static BOOL CALLBACK fatal_exit_enum_helper(const HWND hwnd, const LPARAM /*lParam*/)
1832 {
1833         SetWindowPos(hwnd, HWND_NOTOPMOST, NULL, NULL, NULL, NULL, SWP_ASYNCWINDOWPOS | SWP_NOMOVE | SWP_NOSIZE);
1834         return TRUE;
1835 }
1836
1837 void MUtils::OS::fatal_exit(const wchar_t* const errorMessage)
1838 {
1839         g_fatal_exit_lock.enter();
1840
1841         if(!g_fatal_exit_flag.testAndSetOrdered(0, 1))
1842         {
1843                 return; /*prevent recursive invocation*/
1844         }
1845
1846         EnumThreadWindows(g_main_thread_id, fatal_exit_enum_helper, 0L);
1847
1848         if(g_main_thread_id != GetCurrentThreadId())
1849         {
1850                 if(HANDLE hThreadMain = OpenThread(THREAD_SUSPEND_RESUME, FALSE, g_main_thread_id))
1851                 {
1852                         SuspendThread(hThreadMain); /*stop main thread*/
1853                 }
1854         }
1855
1856         MUtils::OS::system_message_err(L"GURU MEDITATION", errorMessage);
1857
1858         for(;;)
1859         {
1860                 TerminateProcess(GetCurrentProcess(), 666);
1861         }
1862 }
1863
1864 ///////////////////////////////////////////////////////////////////////////////