src/OSSupport_Win32.cpp

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