Merge pull request #510 from GameTechDev/injection-rainbow-side

Injection rainbow side

Author: markgalvan-intel

.gitignore

@@ -60,3 +60,5 @@ PresentMon/ddETWExternalEventsTEMP.BIN
 
 # Local runsettings files (user-specific test configurations)
 *.local.runsettings
+
+Directory.Build.props

IntelPresentMon/AppCef/ipm-ui-vue/src/views/FlashConfigView.vue

@@ -97,8 +97,8 @@ watch(
 
       <v-row class="mt-8">
         <v-col cols="3">
-          Rainbow Flash
-          <p class="text-medium-emphasis text-caption mb-0">Cycle through a rainbow of colors instead of using above flash color.</p>
+          Rainbow Strip
+          <p class="text-medium-emphasis text-caption mb-0">Draw a strip on the left-hand side of the screen that cycles through colors every frame.</p>
         </v-col>
         <v-col cols="9">
           <v-switch v-model="prefs.preferences.flashInjectionUseRainbow" label="Enable"></v-switch>

IntelPresentMon/CommonUtilities/win/com/ProcessSpawnSink.h

@@ -31,7 +31,7 @@ namespace pmon::util::win::com
             std::function<void()> notificationFunction_;
         };
         // functions
-        ProcessSpawnSink(EventQueue& queue, float delayToleranceSeconds = 0.4);
+        ProcessSpawnSink(EventQueue& queue, float delayToleranceSeconds = 0.5);
         HRESULT STDMETHODCALLTYPE Indicate(LONG count,
             IWbemClassObject __RPC_FAR* __RPC_FAR* pObjArr) override;
         std::string GetQueryString() const override;

IntelPresentMon/Core/source/cli/CliOptions.h

@@ -26,6 +26,7 @@ namespace p2c::cli
 		Flag traceExceptions{ this, "--trace-exceptions", "Add stack trace to all thrown exceptions (including SEH exceptions)" };
 		Flag enableDiagnostic{ this, "--enable-diagnostic", "Enable debug diagnostic layer forwarding (duplicates exiisting log entries)" };
 		Flag filesWorking{ this, "--files-working", "Use the working directory for file storage" };
+		Flag waitForDebugger{ this, "--wait-for-debugger", "On entry wait for debugger to be attached, then break" };
 
 	private: Group gl_{ this, "Logging", "Customize logging for this tool"}; public:
 		Option<log::Level> logLevel{ this, "--log-level", log::Level::Error, "Severity to log at", logLevelTf_ };

IntelPresentMon/Core/source/kernel/InjectorComplex.cpp

@@ -54,22 +54,38 @@ namespace p2c::kern
 	InjectorComplex::InjectorModule_::InjectorModule_(bool is32Bit)
 		:
 		pipeOut_{ ioctx_ },
-		pipeIn_{ ioctx_ }
+		pipeIn_{ ioctx_ },
+		pipeErr_{ ioctx_ },
+		is32Bit_{ is32Bit },
+		injectorProcess_{ ioctx_ }
 	{
 		// Determine the correct injector executable
 		auto exe = is32Bit
 			? "FlashInjector-Win32.exe"
 			: "FlashInjector-x64.exe";
-		auto path = std::filesystem::current_path() / exe;
 
-		// Spawn the child with Asio pipes for stdin/stdout (stderr inherited)
-		injectorProcess_.emplace(
+		// Spawn the child with Asio pipes for stdin/stdout/stderr
+		injectorProcess_ = bp2::process{
 			ioctx_,
-			path.string(),
+			exe, // using relative path to injector here due to issue with boost.process (following up)
 			/* no args = */ std::vector<std::string>{},
 			bp2::windows::process_creation_flags<CREATE_NO_WINDOW>(),
-			bp2::process_stdio{ pipeIn_, pipeOut_, nullptr }
-		);
+			bp2::process_stdio{ pipeIn_, pipeOut_, pipeErr_ }
+		};
+
+		// if logging at debug level, pump stderr into pmlog
+		namespace log = ::pmon::util::log;
+		if (log::GlobalPolicy::Get().GetLogLevel() >= log::Level::Debug) {
+			errListenerThread_ = std::jthread{ [this](std::stop_token st) {
+				// when someone does listenerThread_.request_stop(),
+				// this callback will fire and break ioctx_.run()
+				std::stop_callback cb{ st, [this] { ioctx_.stop(); } };
+				// kick off the first async read
+				SpawnReadErrTask_();
+				// enter Asio’s event loop
+				ioctx_.run();
+			} };
+		}
 
 		// Start the listener thread; on stop request we'll call ioctx_.stop()
 		listenerThread_ = std::jthread{ [this](std::stop_token st) {
@@ -149,6 +165,30 @@ namespace p2c::kern
 			}
 		});
 	}
+	void InjectorComplex::InjectorModule_::SpawnReadErrTask_()
+	{
+		as::async_read_until(pipeErr_, errBuffer_, '\n',
+			[this](boost::system::error_code ec, std::size_t /*bytes*/) {
+			if (!ec) {
+				// read a line out from the asio buffer
+				std::istream is(&errBuffer_);
+				std::string stderrLine;
+				std::getline(is, stderrLine);
+
+				try {
+					pmlog_dbg("Stderr from injector").pmwatch(is32Bit_).pmwatch(stderrLine);
+				}
+				catch (...) {
+					pmlog_error("Failed to read stderr from injector");
+				}
+			}
+
+			// queue the next read (unless we're shutting down)
+			if (pipeErr_.is_open()) {
+				SpawnReadErrTask_();
+			}
+		});
+	}
 	void InjectorComplex::InjectorModule_::PushConfig_()
 	{
 		std::lock_guard lk{ actionClientMutex_ };

IntelPresentMon/Core/source/kernel/InjectorComplex.h

@@ -25,16 +25,21 @@ namespace p2c::kern
 
         private:
             void SpawnReadPidTask_();
+            void SpawnReadErrTask_();
             void PushConfig_();
-            as::io_context ioctx_;
+            bool                               is32Bit_;
+            as::io_context                     ioctx_;
             as::writable_pipe                  pipeIn_;     // us to child's stdin
             as::readable_pipe                  pipeOut_;    // child's stdout to us
+            as::readable_pipe                  pipeErr_;    // child's stderr to us
             as::streambuf                      readBuffer_;
+            as::streambuf                      errBuffer_;
             std::jthread                       listenerThread_;
+            std::jthread                       errListenerThread_;
             std::mutex                         actionClientMutex_;
             std::optional<iact::ActionClient>  injectionPointClient_;
             GfxLayer::Extension::OverlayConfig config_;
-            std::optional<bp2::process>        injectorProcess_;
+            bp2::process       injectorProcess_;
         };
     public:
         void SetActive(bool active);

IntelPresentMon/FlashInjector/LibraryInject.cpp

@@ -16,22 +16,22 @@ namespace LibraryInject
     {
         auto hProcess = (win::Handle)OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId);
         if (!hProcess) {
-            LOGI << "OpenProcess failed with [" << win::GetErrorDescription(GetLastError()) << "]; re-attemping with elevated privileges";
+            LOGI << "OpenProcess failed with [" << win::GetErrorDescription(GetLastError()) << "]; re-attemping with elevated privileges" << std::endl;
 
             // Increase privileges
             win::Handle hToken;
             {
                 HANDLE tempHandle;
                 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &tempHandle)) {
-                    LOGE << "OpenProcessToken failed for current process. Error: " << win::GetErrorDescription(GetLastError());
+                    LOGE << "OpenProcessToken failed for current process. Error: " << win::GetErrorDescription(GetLastError()) << std::endl;
                     exit(1);
                 }
                 hToken = win::Handle(tempHandle);
             }
 
             LUID debugPrivilegeId;
             if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &debugPrivilegeId)) {
-                LOGE << "LookupPrivilegeValue failed for current process. Error: " << win::GetErrorDescription(GetLastError());
+                LOGE << "LookupPrivilegeValue failed for current process. Error: " << win::GetErrorDescription(GetLastError()) << std::endl;
                 exit(1);
             }
 
@@ -42,12 +42,12 @@ namespace LibraryInject
                 }
             };
             if (!AdjustTokenPrivileges(hToken, FALSE, &tokenPrivileges, sizeof(tokenPrivileges), NULL, NULL)) {
-                LOGE << "AdjustTokenPrivileges failed for current process. Error: " << win::GetErrorDescription(GetLastError());
+                LOGE << "AdjustTokenPrivileges failed for current process. Error: " << win::GetErrorDescription(GetLastError()) << std::endl;
                 exit(1);
             }
 
             if (!(hProcess = (win::Handle)OpenProcess(PROCESS_ALL_ACCESS, FALSE, processId))) {
-                LOGE << "Could not open process to attach with elevated privileges. Error: " << win::GetErrorDescription(GetLastError());
+                LOGE << "Could not open process to attach with elevated privileges. Error: " << win::GetErrorDescription(GetLastError()) << std::endl;
                 exit(1);
             }
         }
@@ -64,14 +64,14 @@ namespace LibraryInject
         if (pRemoteMem == NULL)
         {
             auto error = GetLastError();
-            LOGE << "Could not allocate memory in target process. Error: " << win::GetErrorDescription(error);
+            LOGE << "Could not allocate memory in target process. Error: " << win::GetErrorDescription(error) << std::endl;
             exit(1);
         }
 
         if (!WriteProcessMemory(hProcess, pRemoteMem, absDllPath.c_str(), remoteMemSize, NULL))
         {
             auto error = GetLastError();
-            LOGE << "WriteProcessMemory failed. Error: " << win::GetErrorDescription(error);
+            LOGE << "WriteProcessMemory failed. Error: " << win::GetErrorDescription(error) << std::endl;
             exit(1);
         }
         FlushInstructionCache(hProcess, pRemoteMem, remoteMemSize);
@@ -91,7 +91,7 @@ namespace LibraryInject
         {
             auto error = GetLastError();
             LOGE << "Could not create remote thread in target process. Error: " << win::GetErrorDescription(error);
-            LOGE << "Tip: Check bit-ness of the application and DXGIOverlay.exe.";
+            LOGE << "Tip: Check bit-ness of the application and DXGIOverlay.exe." << std::endl;
             VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
             exit(1);
         }
@@ -107,4 +107,38 @@ namespace LibraryInject
         auto hTargetProcess = LibraryInject::OpenProcessAndMaybeElevate_(processId);
         LibraryInject::InjectDll(hTargetProcess, dllPath);
     }
+
+    ProcessMap GetProcessNames()
+    {
+        ProcessMap processMap;
+
+        DWORD processIds[1024];
+        DWORD processIdsSize;
+        EnumProcesses(processIds, sizeof(processIds), &processIdsSize);
+
+        auto processIdsFound = processIdsSize / sizeof(DWORD);
+        for (unsigned idx = 0; idx < processIdsFound; idx++)
+        {
+            auto processId = processIds[idx];
+            if (processId == 0)
+            {
+                continue;
+            }
+
+            auto hProcess = ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, processId);
+            if (!hProcess)
+            {
+                continue;
+            }
+
+            CHAR pProcessName[MAX_PATH] = "NOT_FOUND";
+            GetModuleBaseName(hProcess, 0, pProcessName, sizeof(pProcessName) / sizeof(CHAR));
+
+            CloseHandle(hProcess);
+
+            processMap[processId] = pProcessName;
+        }
+
+        return processMap;
+    }
 }

IntelPresentMon/FlashInjector/LibraryInject.h

@@ -7,5 +7,7 @@
 
 namespace LibraryInject
 {
+	using ProcessMap = std::unordered_map<uint32_t, std::string>;
 	void Attach(uint32_t processId, const std::filesystem::path& dllPath);
+	ProcessMap GetProcessNames();
 }

IntelPresentMon/FlashInjector/Logging.h

@@ -1,5 +1,5 @@
 #pragma once
 #include <iostream>
 
-#define LOGE std::cerr << "\n"
-#define LOGI std::cerr << "\n"
+#define LOGE std::cerr
+#define LOGI std::cerr