src/OSSupport_Win32.cpp

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