include/MUtils/OSSupport.h

   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 /**
  23  * @file
  24  * @brief This file contains function that wrap OS-specific functionality in a platform-independent way
  25  */
  26
  27 #pragma once
  28
  29 //MUtils
  30 #include <MUtils/Global.h>
  31
  32 //Qt
  33 #include <QString>
  34 #include <QMap>
  35 #include <QDate>
  36 #include <QWidget>
  37
  38 //Forward declaration
  39 class QFile;
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 /**
  44 * \brief Global MUtils namespace
  45 */
  46 namespace MUtils
  47 {
  48         /**
  49         * \brief MUtils OS-specific functions namespace
  50         */
  51         namespace OS
  52         {
  53                 /**
  54                 * \brief OS version information namespace
  55                 */
  56                 namespace Version
  57                 {
  58                         /**
  59                         * \brief This enumeration specifies the type of the underlaying operating system
  60                         */
  61                         typedef enum
  62                         {
  63                                 OS_UNKNOWN = 0,  ///< Unknown operating system
  64                                 OS_WINDOWS = 1   ///< Microsoft(R) Windows
  65                         }
  66                         os_type_t;
  67
  68                         /**
  69                         * \brief This struct contains version information about the underlaying operating system. See `_os_version_t` for details!
  70                         */
  71                         typedef struct _os_version_t
  72                         {
  73                                 unsigned int type;          ///< The type of the underlaying operating system, as `os_type_t`
  74                                 unsigned int versionMajor;  ///< The *major* version of the underlaying operating system
  75                                 unsigned int versionMinor;  ///< The *minor* version of the underlaying operating system
  76                                 unsigned int versionBuild;  ///< The *build* number of the underlaying operating system
  77                                 unsigned int versionSPack;  ///< The *service pack* version of the underlaying operating system
  78                                 bool overrideFlag;
  79
  80                                 MUTILS_API bool operator== (const _os_version_t &rhs) const;
  81                                 MUTILS_API bool operator!= (const _os_version_t &rhs) const;
  82                                 MUTILS_API bool operator>  (const _os_version_t &rhs) const;
  83                                 MUTILS_API bool operator>= (const _os_version_t &rhs) const;
  84                                 MUTILS_API bool operator<  (const _os_version_t &rhs) const;
  85                                 MUTILS_API bool operator<= (const _os_version_t &rhs) const;
  86                         }
  87                         os_version_t;
  88
  89                         //Known Windows NT versions
  90                         MUTILS_API extern const os_version_t WINDOWS_WIN2K;  ///< \brief Operating system version constant \details Microsoft(R) Windows 2000
  91                         MUTILS_API extern const os_version_t WINDOWS_WINXP;  ///< \brief Operating system version constant \details Microsoft(R) Windows XP
  92                         MUTILS_API extern const os_version_t WINDOWS_XPX64;  ///< \brief Operating system version constant \details Microsoft(R) Windows XP x64-edition
  93                         MUTILS_API extern const os_version_t WINDOWS_VISTA;  ///< \brief Operating system version constant \details Microsoft(R) Windows Vista
  94                         MUTILS_API extern const os_version_t WINDOWS_WIN70;  ///< \brief Operating system version constant \details Microsoft(R) Windows 7
  95                         MUTILS_API extern const os_version_t WINDOWS_WIN80;  ///< \brief Operating system version constant \details Microsoft(R) Windows 8
  96                         MUTILS_API extern const os_version_t WINDOWS_WIN81;  ///< \brief Operating system version constant \details Microsoft(R) Windows 8.1
  97                         MUTILS_API extern const os_version_t WINDOWS_WN100;  ///< \brief Operating system version constant \details Microsoft(R) Windows 10
  98
  99                         //Unknown OS
 100                         MUTILS_API extern const os_version_t UNKNOWN_OPSYS;  ///< \brief Operating system version constant \details Unknown operating system version
 101                 }
 102
 103                 /**
 104                 * \brief This enumeration specifies possible operating system architectures
 105                 */
 106                 typedef enum
 107                 {
 108                         ARCH_X86 = 1, ///< Intel x86 or compatible [32-bit]
 109                         ARCH_X64 = 2  ///< x86-64, aka AMD64, aka Intel 64 [64-bit]
 110                 }
 111                 os_arch_t;
 112
 113                 /**
 114                 * \brief This enumeration specifies "known" folder identifiers
 115                 */
 116                 typedef enum
 117                 {
 118                         FOLDER_PROFILE_USER  =  1,  ///< The user's profile folder
 119                         FOLDER_PROFILE_PUBL  =  2,  ///< The "all users" profile folder
 120                         FOLDER_APPDATA_ROAM  =  3,  ///< Application-specific data
 121                         FOLDER_APPDATA_LOCA  =  4,  ///< Local application data (non-roaming)
 122                         FOLDER_DOCS_USER     =  5,  ///< The user's Documents directory
 123                         FOLDER_DOCS_PUBL     =  6,  ///< The "all users" Documents directory
 124                         FOLDER_DESKTOP_USER  =  7,  ///< The user's Desktop directory
 125                         FOLDER_DESKTOP_PUBL  =  8,  ///< The "all users" Desktop directory
 126                         FOLDER_PICTURES_USER =  9,  ///< The user's Music directory
 127                         FOLDER_PICTURES_PUBL = 10,  ///< The user's Music directory
 128                         FOLDER_MUSIC_USER    = 11,  ///< The user's Music directory
 129                         FOLDER_MUSIC_PUBL    = 12,  ///< The "all users" Music directory
 130                         FOLDER_VIDEO_USER    = 13,  ///< The user's Video directory
 131                         FOLDER_VIDEO_PUBL    = 14,  ///< The "all users" Video directory
 132                         FOLDER_PROGRAMS_DEF  = 15,  ///< Program files
 133                         FOLDER_PROGRAMS_X86  = 16,  ///< Program files
 134                         FOLDER_PROGRAMS_X64  = 17,  ///< Program files
 135                         FOLDER_SYSROOT       = 18,  ///< System "root" directory
 136                         FOLDER_SYSTEM_DEF    = 19,  ///< System directory
 137                         FOLDER_SYSTEM_X86    = 20,  ///< System directory for x86 (32-Bit)
 138                 }
 139                 known_folder_t;
 140
 141                 /**
 142                 * \brief This enumeration specifies network connection types
 143                 */
 144                 typedef enum
 145                 {
 146                         NETWORK_TYPE_ERR = 0,  ///< Network connection is unknown
 147                         NETWORK_TYPE_NON = 1,  ///< Computer is **not** connected to a network
 148                         NETWORK_TYPE_YES = 2   ///< Computer *is* connected to a network
 149                 }
 150                 network_type_t;
 151
 152                 /**
 153                 * \brief This enumeration specifies drive types
 154                 */
 155                 typedef enum
 156                 {
 157                         DRIVE_TYPE_ERR = 0,  ///< The drive type cannot be determined
 158                         DRIVE_TYPE_FDD = 1,  ///< Floppy Drive, or Flash Card reader
 159                         DRIVE_TYPE_HDD = 2,  ///< Hard Disk drive or Solid-State Drive
 160                         DRIVE_TYPE_NET = 3,  ///< Remote/Network drive
 161                         DRIVE_TYPE_OPT = 4,  ///< Optical disk srive, e.g. CD or DVD
 162                         DRIVE_TYPE_RAM = 5   ///< RAM disk
 163                 }
 164                 drive_type_t;
 165
 166                 //System message
 167                 MUTILS_API void system_message_nfo(const wchar_t *const title, const wchar_t *const text);
 168                 MUTILS_API void system_message_wrn(const wchar_t *const title, const wchar_t *const text);
 169                 MUTILS_API void system_message_err(const wchar_t *const title, const wchar_t *const text);
 170
 171                 //CLI Arguments
 172                 typedef QMap<QString,QString> ArgumentMap;
 173                 MUTILS_API const QStringList crack_command_line(const QString &command_line = QString());
 174                 MUTILS_API const ArgumentMap &arguments(void);
 175
 176                 //Copy file
 177                 typedef bool (*progress_callback_t)(const double &progress, void *const userData);
 178                 MUTILS_API bool copy_file(const QString &sourcePath, const QString &outputPath, const bool &overwrite = true, const progress_callback_t callback = NULL, void *const userData = NULL);
 179
 180                 //Get file version
 181                 MUTILS_API bool get_file_version(const QString fileName, quint16 *const major = NULL, quint16 *const minor = NULL, quint16 *const patch = NULL, quint16 *const build = NULL);
 182
 183                 //Get the OS version
 184                 MUTILS_API const Version::os_version_t &os_version(void);
 185                 MUTILS_API const char *os_friendly_name(const MUtils::OS::Version::os_version_t &os_version);
 186                 MUTILS_API const bool &running_on_wine(void);
 187                 MUTILS_API const os_arch_t &os_architecture(void);
 188
 189                 //Get known Folder
 190                 MUTILS_API const QString &known_folder(const known_folder_t folder_id);
 191
 192                 //Current Date & Time
 193                 MUTILS_API QDate current_date(void);
 194                 MUTILS_API quint64 current_file_time(void);
 195
 196                 //Check for process elevation
 197                 MUTILS_API bool is_elevated(bool *bIsUacEnabled = NULL);
 198                 MUTILS_API bool user_is_admin(void);
 199
 200                 /**
 201                 * \brief Check the network status
 202                 *
 203                 * Checks whether the computer is *currently* connected to a network. Note that an existing network connection does **not** necessarily imply actual Internet access!
 204                 *
 205                 * \return The function returns the current network status as a `OS::network_type_t` value.
 206                 */
 207                 MUTILS_API int network_status(void);
 208
 209                 //Message handler
 210                 MUTILS_API bool handle_os_message(const void *const message, long *result);
 211
 212                 /**
 213                 * \brief Suspend calling thread
 214                 *
 215                 * This function suspends the calling thread. The thread will give up its current time-slice and enter "sleeping" state. The thread will remain in "sleeping" for the specified duration. After the specified duration has elapsed, the thread will be resumed.
 216                 *
 217                 * Note that it depends on the operating system's scheduling decisions, when the thread will actually be allowed to execute again! While the thread is still in "sleeping" state, it can **not** be selected for execution by the operating system's scheduler. Once the thread is *no* longer in "sleeping" state, i.e. the specified period has elapsed, the thread *can* be selected for execution by the operating system's scheduler again - but this does **not** need to happen *immediately*! The scheduler decides which thread is allowed to execute next, taking into consideration thread priorities.
 218                 *
 219                 * \param duration The amount of time that the thread will be suspended, in milliseconds. A value of **0** means that the thread will *not* actually enter "sleeping" state, but it will still give up its current time-slice!
 220                 */
 221                 MUTILS_API void sleep_ms(const size_t &duration);
 222
 223                 //Is executable/library file?
 224                 MUTILS_API bool is_executable_file(const QString &path);
 225                 MUTILS_API bool is_library_file(const QString &path);
 226
 227                 //Shutdown & Hibernation
 228                 MUTILS_API bool is_hibernation_supported(void);
 229                 MUTILS_API bool shutdown_computer(const QString &message, const unsigned long timeout, const bool forceShutdown, const bool hibernate);
 230
 231                 //Free diskspace
 232                 MUTILS_API bool free_diskspace(const QString &path, quint64 &freeSpace);
 233
 234                 /**
 235                 * \brief Detect drive type
 236                 *
 237                 * This function detetcs the type of the drive to which the given path is pointing.
 238                 *
 239                 * \param path The path to the drive whose type is to be detected. On the Windows platform, only the drive letter is relevant.
 240                 *
 241                 * \param fast_seeking Pointer to a variable that will be set to TRUE, if the drive supports "fast" seeking (e.g. SSD or similar device), or to FALSE otherwise. This parameter is optional and may be NULL.
 242                 *
 243                 * \return The function returns the type of the drive as a `OS::drive_type_t` value. In case of error, the value `DRIVE_TYPE_ERR` will be returned.
 244                 */
 245                 MUTILS_API drive_type_t get_drive_type(const QString &path, bool *fast_seeking = NULL);
 246
 247                 //Shell open
 248                 MUTILS_API bool shell_open(const QWidget *parent, const QString &url, const bool explore = false);
 249                 MUTILS_API bool shell_open(const QWidget *parent, const QString &url, const QString &parameters, const QString &directory, const bool explore = false);
 250
 251                 //Open media file
 252                 MUTILS_API bool open_media_file(const QString &mediaFilePath);
 253
 254                 //Process priority
 255                 MUTILS_API bool change_process_priority(const int priority);
 256                 MUTILS_API bool change_process_priority(const QProcess *proc, const int priority);
 257
 258                 //Process ID
 259                 MUTILS_API quint32 process_id(void);
 260                 MUTILS_API quint32 process_id(const QProcess *const proc);
 261
 262                 //Thread ID
 263                 MUTILS_API quint32 thread_id(void);
 264                 MUTILS_API quint32 thread_id(const QProcess *const proc);
 265
 266                 //Suspend or resume processv
 267                 MUTILS_API bool suspend_process(const QProcess *proc, const bool suspend);
 268
 269                 //System timer resolution
 270                 MUTILS_API bool setup_timer_resolution(const quint32 &interval = 1);
 271                 MUTILS_API bool reset_timer_resolution(const quint32 &interval = 1);
 272
 273                 //Set file time
 274                 MUTILS_API bool set_file_time(const QFile &file,   const QDateTime &created = QDateTime(), const QDateTime &modified = QDateTime(), const QDateTime &accessed = QDateTime());
 275                 MUTILS_API bool set_file_time(const QString &path, const QDateTime &created = QDateTime(), const QDateTime &modified = QDateTime(), const QDateTime &accessed = QDateTime());
 276
 277                 //Keyboard support
 278                 MUTILS_API bool check_key_state_esc(void);
 279
 280                 //Shell notification
 281                 MUTILS_API void shell_change_notification(void);
 282
 283                 //Get file path from descriptor
 284                 MUTILS_API QString get_file_path(const int &fd);
 285
 286                 //WOW64 redirection
 287                 MUTILS_API bool wow64fsredir_disable(uintptr_t &oldValue);
 288                 MUTILS_API bool wow64fsredir_revert (const uintptr_t oldValue);
 289
 290                 //Environment variables
 291                 MUTILS_API QString get_envvar(const QString &name);
 292                 MUTILS_API bool set_envvar(const QString &name, const QString &value);
 293
 294                 //NULL device
 295                 MUTILS_API const QLatin1String &null_device(void);
 296
 297                 //Check if debugger is present
 298                 MUTILS_API void check_debugger(void);
 299
 300                 //Error handling
 301                 MUTILS_API void fatal_exit(const wchar_t* const errorMessage);
 302         }
 303 }
 304
 305 ///////////////////////////////////////////////////////////////////////////////