Merge pull request #412 from elaberge/ansi

opcm · web-flow · commit b3fc57c6af28 · 2022-07-11T15:36:58.000+02:00
Handle non-Unicode configurations
diff --git a/src/cpucounters.cpp b/src/cpucounters.cpp
@@ -103,8 +103,8 @@ bool PCM::initWinRing0Lib()
 
     BYTE major, minor, revision, release;
     GetDriverVersion(&major, &minor, &revision, &release);
-    wchar_t buffer[128];
-    swprintf_s(buffer, 128, _T("\\\\.\\WinRing0_%d_%d_%d"),(int)major,(int)minor, (int)revision);
+    TCHAR buffer[128];
+    _stprintf_s(buffer, 128, TEXT("\\\\.\\WinRing0_%d_%d_%d"),(int)major,(int)minor, (int)revision);
     restrictDriverAccess(buffer);
 
     return true;
@@ -1087,11 +1087,11 @@ bool PCM::discoverSystemTopology()
         }
         else
         {
-            std::wcerr << "Error in Windows function 'GetLogicalProcessorInformationEx': " <<
+            tcerr << "Error in Windows function 'GetLogicalProcessorInformationEx': " <<
                 GetLastError() << " ";
             const TCHAR * strError = _com_error(GetLastError()).ErrorMessage();
-            if (strError) std::wcerr << strError;
-            std::wcerr << "\n";
+            if (strError) tcerr << strError;
+            tcerr << "\n";
             return false;
         }
     }
@@ -2121,8 +2121,8 @@ PCM::PCM() :
     // drv.stop();     // restart driver (usually not needed)
     if (!drv.start())
     {
-        std::wcerr << "Cannot access CPU counters\n";
-        std::wcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
+        tcerr << "Cannot access CPU counters\n";
+        tcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
         return;
     }
 #endif
diff --git a/src/cpucounters.h b/src/cpucounters.h
@@ -66,7 +66,7 @@
 namespace pcm {
 
 #ifdef _MSC_VER
-void PCM_API restrictDriverAccess(LPCWSTR path);
+void PCM_API restrictDriverAccess(LPCTSTR path);
 #endif
 
 class SystemCounterState;
diff --git a/src/mmio.cpp b/src/mmio.cpp
@@ -43,15 +43,15 @@ class PCMPmem : public WinPmem {
         switch (sys_info.wProcessorArchitecture)
         {
         case PROCESSOR_ARCHITECTURE_AMD64:
-            wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_x64.sys");
+            _tcscat_s(driver_filename, MAX_PATH, TEXT("\\winpmem_x64.sys"));
             if (GetFileAttributes(driver_filename) == INVALID_FILE_ATTRIBUTES)
             {
                 std::cerr << "ERROR: winpmem_x64.sys not found in current directory. Download it from https://github.com/Velocidex/WinPmem/blob/master/kernel/binaries/winpmem_x64.sys .\n";
                 std::cerr << "ERROR: Memory bandwidth statistics will not be available.\n";
             }
             break;
         case PROCESSOR_ARCHITECTURE_INTEL:
-            wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_x86.sys");
+            _tcscat_s(driver_filename, MAX_PATH, TEXT("\\winpmem_x86.sys"));
             if (GetFileAttributes(driver_filename) == INVALID_FILE_ATTRIBUTES)
             {
                 std::cerr << "ERROR: winpmem_x86.sys not found in current directory. Download it from https://github.com/Velocidex/WinPmem/blob/master/kernel/binaries/winpmem_x86.sys .\n";
diff --git a/src/pcm-memory.cpp b/src/pcm-memory.cpp
@@ -1123,8 +1123,8 @@ int main(int argc, char * argv[])
             Driver tmpDrvObject = Driver(Driver::msrLocalPath());
             if (!tmpDrvObject.start())
             {
-                wcerr << "Can not access CPU counters\n";
-                wcerr << "You must have a signed  driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";
+                tcerr << "Can not access CPU counters\n";
+                tcerr << "You must have a signed  driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";
                 exit(EXIT_FAILURE);
             }
             exit(EXIT_SUCCESS);
diff --git a/src/pcm-msr.cpp b/src/pcm-msr.cpp
@@ -83,8 +83,8 @@ int main(int argc, char * argv[])
     // drv.stop();     // restart driver (usually not needed)
     if (!drv.start())
     {
-        std::wcerr << "Can not load MSR driver.\n";
-        std::wcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
+        tcerr << "Can not load MSR driver.\n";
+        tcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
         return -1;
     }
     #endif
diff --git a/src/pcm-pcicfg.cpp b/src/pcm-pcicfg.cpp
@@ -83,8 +83,8 @@ int main(int argc, char * argv[])
     // drv.stop();     // restart driver (usually not needed)
     if (!drv.start())
     {
-        std::wcerr << "Can not load MSR driver.\n";
-        std::wcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
+        tcerr << "Can not load MSR driver.\n";
+        tcerr << "You must have a signed  driver at " << drv.driverPath() << " and have administrator rights to run this program\n";
         return -1;
     }
     #endif
diff --git a/src/pcm.cpp b/src/pcm.cpp
@@ -1306,8 +1306,8 @@ int main(int argc, char * argv[])
             Driver tmpDrvObject = Driver(Driver::msrLocalPath());
             if (!tmpDrvObject.start())
             {
-                wcerr << "Can not access CPU counters\n";
-                wcerr << "You must have a signed  driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";
+                tcerr << "Can not access CPU counters\n";
+                tcerr << "You must have a signed  driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";
                 exit(EXIT_FAILURE);
             }
             exit(EXIT_SUCCESS);
diff --git a/src/utils.cpp b/src/utils.cpp
@@ -264,18 +264,18 @@ void set_signal_handlers(void)
 // to fix Cygwin/BASH setting Ctrl+C handler need first to restore the default one
     handlerStatus = SetConsoleCtrlHandler(NULL, FALSE); // restores normal processing of CTRL+C input
     if (handlerStatus == 0) {
-        std::wcerr << "Failed to set Ctrl+C handler. Error code: " << GetLastError() << " ";
+        tcerr << "Failed to set Ctrl+C handler. Error code: " << GetLastError() << " ";
         const TCHAR * errorStr = _com_error(GetLastError()).ErrorMessage();
-        if (errorStr) std::wcerr << errorStr;
-        std::wcerr << "\n";
+        if (errorStr) tcerr << errorStr;
+        tcerr << "\n";
         _exit(EXIT_FAILURE);
     }
     handlerStatus = SetConsoleCtrlHandler((PHANDLER_ROUTINE)sigINT_handler, TRUE);
     if (handlerStatus == 0) {
-        std::wcerr << "Failed to set Ctrl+C handler. Error code: " << GetLastError() << " ";
+        tcerr << "Failed to set Ctrl+C handler. Error code: " << GetLastError() << " ";
         const TCHAR * errorStr = _com_error(GetLastError()).ErrorMessage();
-        if (errorStr) std::wcerr << errorStr;
-        std::wcerr << "\n";
+        if (errorStr) tcerr << errorStr;
+        tcerr << "\n";
         _exit(EXIT_FAILURE);
     }
     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)&unhandled_exception_handler);
diff --git a/src/utils.h b/src/utils.h
@@ -29,6 +29,15 @@
 
 namespace pcm {
 
+#ifdef _MSC_VER
+    using tstring = std::basic_string<TCHAR>;
+#ifdef UNICODE
+    static auto& tcerr = std::wcerr;
+#else
+    static auto& tcerr = std::cerr;
+#endif
+#endif // _MSC_VER
+
 void exit_cleanup(void);
 void set_signal_handlers(void);
 void set_real_time_priority(const bool & silent);
@@ -80,7 +89,7 @@ void MySystem(char * sysCmd, char ** argc);
 #endif
 struct null_stream : public std::streambuf
 {
-    void overflow(char) { }
+    int_type overflow(int_type) override { return {}; }
 };
 #ifdef __GCC__
 #pragma GCC diagnostic pop
@@ -474,7 +483,7 @@ std::string safe_getenv(const char* env);
 #ifdef _MSC_VER
 inline HANDLE openMSRDriver()
 {
-    return CreateFile(L"\\\\.\\RDMSR", GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+    return CreateFile(TEXT("\\\\.\\RDMSR"), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
 }
 #endif
 
diff --git a/src/windows/PCMService.h b/src/windows/PCMService.h
@@ -10,6 +10,11 @@
 #include "pcm-lib.h"
 #include "windriver.h"
 #include <stdexcept>
+
+#ifndef UNICODE
+#include <locale>
+#include <codecvt>
+#endif
 #pragma managed
 
 using namespace pcm;
@@ -743,29 +748,29 @@ namespace PCMServiceNS {
 
             // Read configuration values from registry
             HKEY hkey;
-            if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\pcm\\service", NULL, KEY_READ, &hkey))
+            if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\pcm\\service"), NULL, KEY_READ, &hkey))
             {
                 DWORD regDWORD = static_cast<DWORD>(REG_DWORD);
                 DWORD lenDWORD = 32;
 
                 DWORD sampleRateRead(0);
-                if (ERROR_SUCCESS == RegQueryValueEx(hkey, L"SampleRate", NULL, NULL, reinterpret_cast<LPBYTE>(&sampleRateRead), &lenDWORD))
+                if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("SampleRate"), NULL, NULL, reinterpret_cast<LPBYTE>(&sampleRateRead), &lenDWORD))
                 {
                     sampleRate = (int)sampleRateRead;
                 }
 
                 DWORD collectCoreRead(0);
-                if (ERROR_SUCCESS == RegQueryValueEx(hkey, L"CollectCore", NULL, NULL, reinterpret_cast<LPBYTE>(&collectCoreRead), &lenDWORD)) {
+                if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CollectCore"), NULL, NULL, reinterpret_cast<LPBYTE>(&collectCoreRead), &lenDWORD)) {
                     collectionInformation->core = (int)collectCoreRead > 0;
                 }
 
                 DWORD collectSocketRead(0);
-                if (ERROR_SUCCESS == RegQueryValueEx(hkey, L"CollectSocket", NULL, NULL, reinterpret_cast<LPBYTE>(&collectSocketRead), &lenDWORD)) {
+                if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CollectSocket"), NULL, NULL, reinterpret_cast<LPBYTE>(&collectSocketRead), &lenDWORD)) {
                     collectionInformation->socket = (int)collectSocketRead > 0;
                 }
 
                 DWORD collectQpiRead(0);
-                if (ERROR_SUCCESS == RegQueryValueEx(hkey, L"CollectQpi", NULL, NULL, reinterpret_cast<LPBYTE>(&collectQpiRead), &lenDWORD)) {
+                if (ERROR_SUCCESS == RegQueryValueEx(hkey, TEXT("CollectQpi"), NULL, NULL, reinterpret_cast<LPBYTE>(&collectQpiRead), &lenDWORD)) {
                     collectionInformation->qpi = (int)collectQpiRead > 0;
                 }
 
@@ -778,7 +783,13 @@ namespace PCMServiceNS {
             drv_ = new Driver;
             if (!drv_->start())
             {
-                String^ s = gcnew String((L"Cannot open the driver.\nYou must have a signed driver at " + drv_->driverPath() + L" and have administrator rights to run this program.\n\n").c_str());
+#ifdef UNICODE
+                const auto& driverPath = drv_->driverPath();
+#else
+                std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> char_to_wide;
+                std::wstring driverPath = char_to_wide.from_bytes(drv_->driverPath().c_str());
+#endif
+                String^ s = gcnew String((L"Cannot open the driver.\nYou must have a signed driver at " + driverPath + L" and have administrator rights to run this program.\n\n").c_str());
                 EventLog->WriteEntry(Globals::ServiceName, s, EventLogEntryType::Error);
                 SetServiceFail(ERROR_FILE_NOT_FOUND);
                 throw gcnew Exception(s);
diff --git a/src/windows/restrictDriverAccess.cpp b/src/windows/restrictDriverAccess.cpp
@@ -5,8 +5,16 @@
 
 namespace pcm {
 
+#ifdef _MSC_VER
+#ifdef UNICODE
+    static auto& tcerr = std::wcerr;
+#else
+    static auto& tcerr = std::cerr;
+#endif
+#endif // _MSC_VER
+
 //! restrict usage of driver to system (SY) and builtin admins (BA)
-void restrictDriverAccess(LPCWSTR path)
+void restrictDriverAccess(LPCTSTR path)
 {
     try {
         System::Security::AccessControl::FileSecurity^ fSecurity = System::IO::File::GetAccessControl(gcnew System::String(path));
@@ -15,7 +23,7 @@ void restrictDriverAccess(LPCWSTR path)
     }
     catch (...)
     {
-        std::wcerr << "Error in GetAccessControl/SetSecurityDescriptorSddlForm for " << path << " driver.\n";
+        tcerr << "Error in GetAccessControl/SetSecurityDescriptorSddlForm for " << path << " driver.\n";
     }
 }
 
diff --git a/src/windows/windriver.h b/src/windows/windriver.h
@@ -19,7 +19,7 @@ namespace pcm {
         \brief Loading and unloading custom Windows MSR (Model Specific Register) Driver
 */
 
-extern void restrictDriverAccess(LPCWSTR path);
+extern void restrictDriverAccess(LPCTSTR path);
 
 /*! \brief Manage custom Windows MSR (Model Specific Register) Driver
     The driver is required to access hardware Model Specific Registers (MSRs)
@@ -33,9 +33,9 @@ class Driver
     SERVICE_STATUS ss{};
 
 public:
-    static std::wstring msrLocalPath()
+    static tstring msrLocalPath()
     {
-        std::wstring driverPath;
+        tstring driverPath;
         DWORD driverPathLen = 1;
         DWORD gcdReturn = 0;
 
@@ -50,27 +50,27 @@ class Driver
 
         removeNullTerminator(driverPath);
 
-        return driverPath + L"\\msr.sys";
+        return driverPath + TEXT("\\msr.sys");
     }
 
     Driver() :
-        Driver(L"c:\\windows\\system32\\msr.sys")
+        Driver(TEXT("c:\\windows\\system32\\msr.sys"))
     {
     }
 
-    Driver(const std::wstring& driverPath) :
-        Driver(driverPath, L"PCM MSR", L"PCM MSR Driver")
+    Driver(const tstring& driverPath) :
+        Driver(driverPath, TEXT("PCM MSR"), TEXT("PCM MSR Driver"))
     {
     }
 
-    Driver(const std::wstring& driverPath, const std::wstring& driverName, const std::wstring& driverDescription) :
-        driverPath_(setConfigValue(L"DriverPath", driverPath)),
-        driverName_(setConfigValue(L"DriverName", driverName)),
-        driverDescription_(setConfigValue(L"DriverDescription", driverDescription))
+    Driver(const tstring& driverPath, const tstring& driverName, const tstring& driverDescription) :
+        driverPath_(setConfigValue(TEXT("DriverPath"), driverPath)),
+        driverName_(setConfigValue(TEXT("DriverName"), driverName)),
+        driverDescription_(setConfigValue(TEXT("DriverDescription"), driverDescription))
     {
     }
 
-    const std::wstring& driverPath() const
+    const tstring& driverPath() const
     {
         return driverPath_;
     }
@@ -100,8 +100,8 @@ class Driver
             {
                 if (0 != StartService(hService, 0, NULL))
                 {
-                    std::wstring convDriverName(&driverName_[0]);
-                    std::wstring driverPath = L"\\\\.\\" + convDriverName;
+                    tstring convDriverName(&driverName_[0]);
+                    tstring driverPath = TEXT("\\\\.\\") + convDriverName;
                     restrictDriverAccess(driverPath.c_str());
                     return true;
                 }
@@ -207,19 +207,17 @@ class Driver
 
 private:
 
-    static std::wstring setConfigValue(const LPCWSTR key, const std::wstring& defaultValue)
+    static tstring setConfigValue(LPCTSTR key, const tstring& defaultValue)
     {
-        static_assert(std::is_same<WCHAR, wchar_t>::value, "WCHAR expected to be wchar_t");
-
-        std::wstring regRead;
-        DWORD regLen = 1 * sizeof(WCHAR);
+        tstring regRead;
+        DWORD regLen = 1 * sizeof(TCHAR);
         DWORD regRes = ERROR_FILE_NOT_FOUND; // Safe error to start with in case key doesn't exist
 
         HKEY hKey;
-        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\pcm", NULL, KEY_READ, &hKey))
+        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\pcm"), NULL, KEY_READ, &hKey))
         {
             do {
-                regRead.resize(regLen / sizeof(WCHAR));
+                regRead.resize(regLen / sizeof(TCHAR));
                 regRes = RegQueryValueEx(hKey, key, NULL, NULL, (LPBYTE)&regRead[0], &regLen);
             } while (ERROR_MORE_DATA == regRes);
 
@@ -231,17 +229,17 @@ class Driver
         return ERROR_SUCCESS == regRes ? regRead : defaultValue;
     }
 
-    static void removeNullTerminator(std::wstring& s)
+    static void removeNullTerminator(tstring& s)
     {
         if (!s.empty() && s.back() == '\0')
         {
             s.pop_back();
         }
     }
 
-    const std::wstring driverName_;
-    const std::wstring driverPath_;
-    const std::wstring driverDescription_;
+    const tstring driverName_;
+    const tstring driverPath_;
+    const tstring driverDescription_;
 };
 
 } // namespace pcm
diff --git a/src/winpmem/winpmem.cpp b/src/winpmem/winpmem.cpp

Original file line number	Diff line number	Diff line change
`@@ -103,8 +103,8 @@ bool PCM::initWinRing0Lib()`
`103`	`103`
`104`	`104`	`BYTE major, minor, revision, release;`
`105`	`105`	`GetDriverVersion(&major, &minor, &revision, &release);`
`106`		`- wchar_t buffer[128];`
`107`		`- swprintf_s(buffer, 128, _T("\\\\.\\WinRing0_%d_%d_%d"),(int)major,(int)minor, (int)revision);`
	`106`	`+ TCHAR buffer[128];`
	`107`	`+ _stprintf_s(buffer, 128, TEXT("\\\\.\\WinRing0_%d_%d_%d"),(int)major,(int)minor, (int)revision);`
`108`	`108`	`restrictDriverAccess(buffer);`
`109`	`109`
`110`	`110`	`return true;`
`@@ -1087,11 +1087,11 @@ bool PCM::discoverSystemTopology()`
`1087`	`1087`	`}`
`1088`	`1088`	`else`
`1089`	`1089`	`{`
`1090`		`- std::wcerr << "Error in Windows function 'GetLogicalProcessorInformationEx': " <<`
	`1090`	`+ tcerr << "Error in Windows function 'GetLogicalProcessorInformationEx': " <<`
`1091`	`1091`	`GetLastError() << " ";`
`1092`	`1092`	`const TCHAR * strError = _com_error(GetLastError()).ErrorMessage();`
`1093`		`- if (strError) std::wcerr << strError;`
`1094`		`- std::wcerr << "\n";`
	`1093`	`+ if (strError) tcerr << strError;`
	`1094`	`+ tcerr << "\n";`
`1095`	`1095`	`return false;`
`1096`	`1096`	`}`
`1097`	`1097`	`}`
`@@ -2121,8 +2121,8 @@ PCM::PCM() :`
`2121`	`2121`	`// drv.stop(); // restart driver (usually not needed)`
`2122`	`2122`	`if (!drv.start())`
`2123`	`2123`	`{`
`2124`		`- std::wcerr << "Cannot access CPU counters\n";`
`2125`		`- std::wcerr << "You must have a signed driver at " << drv.driverPath() << " and have administrator rights to run this program\n";`
	`2124`	`+ tcerr << "Cannot access CPU counters\n";`
	`2125`	`+ tcerr << "You must have a signed driver at " << drv.driverPath() << " and have administrator rights to run this program\n";`
`2126`	`2126`	`return;`
`2127`	`2127`	`}`
`2128`	`2128`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,15 @@ class PCMPmem : public WinPmem {`
`43`	`43`	`switch (sys_info.wProcessorArchitecture)`
`44`	`44`	`{`
`45`	`45`	`case PROCESSOR_ARCHITECTURE_AMD64:`
`46`		`- wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_x64.sys");`
	`46`	`+ _tcscat_s(driver_filename, MAX_PATH, TEXT("\\winpmem_x64.sys"));`
`47`	`47`	`if (GetFileAttributes(driver_filename) == INVALID_FILE_ATTRIBUTES)`
`48`	`48`	`{`
`49`	`49`	`std::cerr << "ERROR: winpmem_x64.sys not found in current directory. Download it from https://github.com/Velocidex/WinPmem/blob/master/kernel/binaries/winpmem_x64.sys .\n";`
`50`	`50`	`std::cerr << "ERROR: Memory bandwidth statistics will not be available.\n";`
`51`	`51`	`}`
`52`	`52`	`break;`
`53`	`53`	`case PROCESSOR_ARCHITECTURE_INTEL:`
`54`		`- wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_x86.sys");`
	`54`	`+ _tcscat_s(driver_filename, MAX_PATH, TEXT("\\winpmem_x86.sys"));`
`55`	`55`	`if (GetFileAttributes(driver_filename) == INVALID_FILE_ATTRIBUTES)`
`56`	`56`	`{`
`57`	`57`	`std::cerr << "ERROR: winpmem_x86.sys not found in current directory. Download it from https://github.com/Velocidex/WinPmem/blob/master/kernel/binaries/winpmem_x86.sys .\n";`
Original file line number	Diff line number	Diff line change
`@@ -1123,8 +1123,8 @@ int main(int argc, char * argv[])`
`1123`	`1123`	`Driver tmpDrvObject = Driver(Driver::msrLocalPath());`
`1124`	`1124`	`if (!tmpDrvObject.start())`
`1125`	`1125`	`{`
`1126`		`- wcerr << "Can not access CPU counters\n";`
`1127`		`- wcerr << "You must have a signed driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";`
	`1126`	`+ tcerr << "Can not access CPU counters\n";`
	`1127`	`+ tcerr << "You must have a signed driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";`
`1128`	`1128`	`exit(EXIT_FAILURE);`
`1129`	`1129`	`}`
`1130`	`1130`	`exit(EXIT_SUCCESS);`
Original file line number	Diff line number	Diff line change
`@@ -83,8 +83,8 @@ int main(int argc, char * argv[])`
`83`	`83`	`// drv.stop(); // restart driver (usually not needed)`
`84`	`84`	`if (!drv.start())`
`85`	`85`	`{`
`86`		`- std::wcerr << "Can not load MSR driver.\n";`
`87`		`- std::wcerr << "You must have a signed driver at " << drv.driverPath() << " and have administrator rights to run this program\n";`
	`86`	`+ tcerr << "Can not load MSR driver.\n";`
	`87`	`+ tcerr << "You must have a signed driver at " << drv.driverPath() << " and have administrator rights to run this program\n";`
`88`	`88`	`return -1;`
`89`	`89`	`}`
`90`	`90`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -1306,8 +1306,8 @@ int main(int argc, char * argv[])`
`1306`	`1306`	`Driver tmpDrvObject = Driver(Driver::msrLocalPath());`
`1307`	`1307`	`if (!tmpDrvObject.start())`
`1308`	`1308`	`{`
`1309`		`- wcerr << "Can not access CPU counters\n";`
`1310`		`- wcerr << "You must have a signed driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";`
	`1309`	`+ tcerr << "Can not access CPU counters\n";`
	`1310`	`+ tcerr << "You must have a signed driver at " << tmpDrvObject.driverPath() << " and have administrator rights to run this program\n";`
`1311`	`1311`	`exit(EXIT_FAILURE);`
`1312`	`1312`	`}`
`1313`	`1313`	`exit(EXIT_SUCCESS);`