From 87396866986553b9220d7d1e5dcc49066fd76f5e Mon Sep 17 00:00:00 2001 From: Greg Date: Fri, 6 Jan 2023 22:37:35 -0700 Subject: [PATCH] Target Consoles now have events to fire, mutex protection for debugger, Revamp events so they dont need to be re registered & Impliment all events on host side. --- Misc/General_IPC.h | 6 +- Misc/libjbc.h | 2 +- Playstation/OrbisLibAPI/API.cpp | 9 +- Playstation/OrbisLibAPI/API.h | 2 +- Playstation/OrbisLibAPI/APIPackets.h | 4 +- Playstation/OrbisLibAPI/Common.h | 1 + Playstation/OrbisLibAPI/Config.h | 5 + Playstation/OrbisLibAPI/Debug.cpp | 77 ++++-- Playstation/OrbisLibAPI/Debug.h | 1 + Playstation/OrbisLibAPI/Events.cpp | 119 +++++++++ Playstation/OrbisLibAPI/Events.h | 31 +++ Playstation/OrbisLibAPI/GeneralIPC.cpp | 4 +- Playstation/OrbisLibAPI/GeneralIPC.h | 2 +- Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj | 3 + .../OrbisLibAPI/OrbisLibAPI.vcxproj.filters | 9 + Playstation/OrbisLibAPI/SocketListener.cpp | 12 +- Playstation/OrbisLibAPI/SocketListener.h | 11 +- Playstation/OrbisLibAPI/Version.h | 22 +- Playstation/OrbisLibAPI/main.cpp | 11 + .../OrbisLibGeneralHelper.cpp | 27 +- .../OrbisLib2/Common/API/APIPackets.cs | 2 +- .../Common/Dispatcher/DispatcherClient.cs | 25 +- .../Common/Dispatcher/DispatcherPackets.cs | 5 +- Windows/Libraries/OrbisLib2/General/Events.cs | 236 +++++++++++++++++- Windows/Libraries/OrbisLib2/Targets/Target.cs | 2 - .../OrbisLib2/Targets/TargetEvents.cs | 205 --------------- .../OrbisLib2/Targets/TargetManager.cs | 19 +- .../OrbisLibraryManager.xaml | 2 +- .../OrbisLibraryManager.xaml.cs | 21 ++ .../Resources/BuildNumber.txt | 2 +- .../Resources/BuildString.txt | 2 +- .../OrbisSuiteService/Service/Dispatcher.cs | 4 +- .../Service/TargetEventListener.cs | 83 ++++++ 33 files changed, 670 insertions(+), 296 deletions(-) create mode 100644 Playstation/OrbisLibAPI/Config.h create mode 100644 Playstation/OrbisLibAPI/Events.cpp create mode 100644 Playstation/OrbisLibAPI/Events.h delete mode 100644 Windows/Libraries/OrbisLib2/Targets/TargetEvents.cs create mode 100644 Windows/OrbisSuiteService/Service/TargetEventListener.cs diff --git a/Misc/General_IPC.h b/Misc/General_IPC.h index cd5dc1a..f50ad2f 100644 --- a/Misc/General_IPC.h +++ b/Misc/General_IPC.h @@ -22,6 +22,8 @@ enum GeneralIPCResult struct LibPacket { - char Path[100]; - int Handle; + uint32_t Handle; + char Path[256]; + int SegmentCount; + OrbisKernelModuleSegmentInfo Segments[4]; }; diff --git a/Misc/libjbc.h b/Misc/libjbc.h index 724ad1e..9c9314a 100644 --- a/Misc/libjbc.h +++ b/Misc/libjbc.h @@ -7,7 +7,7 @@ extern "C" struct LibraryInfo { char Path[256]; - uint64_t ModuleHandle; + uint64_t Handle; uint64_t map_base; size_t map_size; size_t text_size; diff --git a/Playstation/OrbisLibAPI/API.cpp b/Playstation/OrbisLibAPI/API.cpp index adc7840..e81ee13 100644 --- a/Playstation/OrbisLibAPI/API.cpp +++ b/Playstation/OrbisLibAPI/API.cpp @@ -1,5 +1,6 @@ #include "Common.h" #include "API.h" +#include "Events.h" Proc* API::Proc; Apps* API::Apps; @@ -8,10 +9,14 @@ Target* API::Target; SocketListener* API::Listener; bool API::Running = false; -void API::ListenerCallback(void* tdParam, OrbisNetId s) +void API::ListenerCallback(void* tdParam, OrbisNetId s, OrbisNetInAddr sin_addr) { + // Deserialize the packet. auto Packet = RecievePacket(s); + // Add host to the host list. + Events::AddHost(sin_addr.s_addr); + if (Packet != nullptr) { // Make sure were getting the proper packet version. @@ -68,7 +73,7 @@ void API::Init() Apps = new class Apps(); Debug = new class Debug(); Target = new class Target(Debug); - Listener = new SocketListener(ListenerCallback, NULL, 6900); + Listener = new SocketListener(ListenerCallback, NULL, API_PORT); Running = true; } diff --git a/Playstation/OrbisLibAPI/API.h b/Playstation/OrbisLibAPI/API.h index db5e439..43679ee 100644 --- a/Playstation/OrbisLibAPI/API.h +++ b/Playstation/OrbisLibAPI/API.h @@ -15,7 +15,7 @@ private: static Target* Target; static SocketListener* Listener; - static void ListenerCallback(void* tdParam, OrbisNetId s); + static void ListenerCallback(void* tdParam, OrbisNetId s, OrbisNetInAddr sin_addr); public: static bool Running; diff --git a/Playstation/OrbisLibAPI/APIPackets.h b/Playstation/OrbisLibAPI/APIPackets.h index 9dde53a..1056eec 100644 --- a/Playstation/OrbisLibAPI/APIPackets.h +++ b/Playstation/OrbisLibAPI/APIPackets.h @@ -191,9 +191,9 @@ struct AppListPacket struct LibraryPacket { - int64_t Handle; + uint32_t Handle; char Path[256]; - int32_t SegmentCount; + int SegmentCount; OrbisKernelModuleSegmentInfo Segments[4]; }; diff --git a/Playstation/OrbisLibAPI/Common.h b/Playstation/OrbisLibAPI/Common.h index d783838..37dc09b 100644 --- a/Playstation/OrbisLibAPI/Common.h +++ b/Playstation/OrbisLibAPI/Common.h @@ -29,6 +29,7 @@ #include #include +#include "Config.h" #include "SocketListener.h" #include "Utilities.h" #include "GoldHEN.h" diff --git a/Playstation/OrbisLibAPI/Config.h b/Playstation/OrbisLibAPI/Config.h new file mode 100644 index 0000000..e07e3f5 --- /dev/null +++ b/Playstation/OrbisLibAPI/Config.h @@ -0,0 +1,5 @@ +#pragma once + +#define API_PORT 6900 + +#define EVENT_PORT 6901 \ No newline at end of file diff --git a/Playstation/OrbisLibAPI/Debug.cpp b/Playstation/OrbisLibAPI/Debug.cpp index 591aeed..1c7a5c5 100644 --- a/Playstation/OrbisLibAPI/Debug.cpp +++ b/Playstation/OrbisLibAPI/Debug.cpp @@ -2,6 +2,7 @@ #include "Debug.h" #include "APIHelper.h" #include "GeneralIPC.h" +#include "Events.h" #include @@ -109,11 +110,17 @@ void Debug::Attach(OrbisNetId Sock) char processName[32]; sceKernelGetProcessName(pid, processName); + // Aquire lock. + scePthreadMutexLock(&DebugMutex); + klog("Attempting to attach to %s (%d)\n", processName, pid); // If we are currently debugging another process lets detach from it. if (!TryDetach(pid)) { + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + klog("Attach(): TryDetach Failed. :(\n"); SendStatus(Sock, 0); return; @@ -123,6 +130,9 @@ void Debug::Attach(OrbisNetId Sock) int res = ptrace(PT_ATTACH, pid, nullptr, 0); if (res != 0) { + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + klog("Attach(): ptrace(PT_ATTACH) failed with error %llX\n", res); SendStatus(Sock, 0); return; @@ -134,14 +144,24 @@ void Debug::Attach(OrbisNetId Sock) res = ptrace(PT_CONTINUE, pid, (void*)1, 0); if (res != 0) { + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + klog("Attach(): ptrace(PT_CONTINUE) failed with error %llX\n", res); SendStatus(Sock, 0); return; } + // Set current debugging state. IsDebugging = true; CurrentPID = pid; + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + + // Send attach event to host. + Events::SendEvent(Events::EVENT_ATTACH, pid); + klog("Attached to %s(%d)\n", processName, pid); SendStatus(Sock, 1); @@ -167,10 +187,30 @@ void Debug::Attach(OrbisNetId Sock) void Debug::Detach(OrbisNetId Sock) { - bool result = false; - if (IsDebugging) - result = TryDetach(CurrentPID); - SendStatus(Sock, result ? 1 : 0); + if(!IsDebugging) + SendStatus(Sock, 0); + + // Aquire lock. + scePthreadMutexLock(&DebugMutex); + + if (TryDetach(CurrentPID)) + { + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + + Events::SendEvent(Events::EVENT_DETACH); + + SendStatus(Sock, 1); + } + else + { + // release the lock. + scePthreadMutexUnlock(&DebugMutex); + + klog("Failed to detach from %d\n", CurrentPID); + + SendStatus(Sock, 0); + } } void Debug::LoadLibrary(OrbisNetId Sock) @@ -259,25 +299,8 @@ void Debug::GetLibraryList(OrbisNetId Sock) } // Get the library list with path. - std::vector klibraryList; - GeneralIPC::GetLibraryList(CurrentPID, klibraryList); - - // Parse the library list. std::vector libraryList; - for (const auto& i : klibraryList) - { - OrbisKernelModuleInfo moduleInfo; - moduleInfo.size = sizeof(OrbisKernelModuleInfo); - sceKernelGetModuleInfo(i.ModuleHandle, &moduleInfo); - - LibraryPacket temp; - temp.Handle = i.ModuleHandle; - strcpy(temp.Path, i.Path); - temp.SegmentCount = moduleInfo.segmentCount; - memcpy(&temp.Segments, &moduleInfo.segmentInfo, sizeof(OrbisKernelModuleSegmentInfo) * 4); - - libraryList.push_back(temp); - } + GeneralIPC::GetLibraryList(CurrentPID, libraryList); // Send the data size. Sockets::SendInt(Sock, libraryList.size()); @@ -290,9 +313,17 @@ Debug::Debug() { IsDebugging = false; CurrentPID = -1; + + // Create the mutex to protect our host list. + auto res = scePthreadMutexInit(&DebugMutex, nullptr, "DebugMutex"); + if (res != 0) + { + klog("Error: Failed to create mutex for Debug class!! Err 0x%llX\n", res); + } } Debug::~Debug() { - + // Destroy for clean up. + scePthreadMutexDestroy(&DebugMutex); } \ No newline at end of file diff --git a/Playstation/OrbisLibAPI/Debug.h b/Playstation/OrbisLibAPI/Debug.h index bd5d7fb..ee0cece 100644 --- a/Playstation/OrbisLibAPI/Debug.h +++ b/Playstation/OrbisLibAPI/Debug.h @@ -3,6 +3,7 @@ class Debug { public: + OrbisPthreadMutex DebugMutex; bool IsDebugging; int CurrentPID; diff --git a/Playstation/OrbisLibAPI/Events.cpp b/Playstation/OrbisLibAPI/Events.cpp new file mode 100644 index 0000000..87231be --- /dev/null +++ b/Playstation/OrbisLibAPI/Events.cpp @@ -0,0 +1,119 @@ +#include "Common.h" +#include "Events.h" + +std::vector< OrbisNetInAddr_t> Events::HostList; +OrbisPthreadMutex Events::HostListMutex; + +bool Events::Init() +{ + // Create the mutex to protect our host list. + auto res = scePthreadMutexInit(&HostListMutex, nullptr, "EventsHostListMutex"); + + if (res != 0) + { + klog("Failed to create mutex for Events Host list. Err: 0x%llX\n", res); + + return false; + } + else + { + return true; + } +} + +void Events::Term() +{ + // Destroy for clean up. + scePthreadMutexDestroy(&HostListMutex); +} + +void Events::AddHost(OrbisNetInAddr_t HostAddress) +{ + // Aquire a lock for the list. + scePthreadMutexLock(&HostListMutex); + + // Add the host to the list if it does not exist already. + if (std::find(HostList.begin(), HostList.end(), HostAddress) == HostList.end()) + { + klog("New host (%i.%i.%i.%i)!\n", HostAddress & 0xFF, (HostAddress >> 8) & 0xFF, (HostAddress >> 16) & 0xFF, (HostAddress >> 24) & 0xFF); + HostList.push_back(HostAddress); + } + + // Revoke the lock on the list. + scePthreadMutexUnlock(&HostListMutex); +} + +void Events::RemoveHost(OrbisNetInAddr_t HostAddress) +{ + // Aquire a lock for the list. + scePthreadMutexLock(&HostListMutex); + + // Remove this host if it exists in the list. + if (std::find(HostList.begin(), HostList.end(), HostAddress) != HostList.end()) + { + klog("Lost host (%i.%i.%i.%i)!\n", HostAddress & 0xFF, (HostAddress >> 8) & 0xFF, (HostAddress >> 16) & 0xFF, (HostAddress >> 24) & 0xFF); + std::remove(HostList.begin(), HostList.end(), HostAddress); + } + + // Revoke the lock on the list. + scePthreadMutexUnlock(&HostListMutex); +} + +OrbisNetId Events::Connect(OrbisNetInAddr_t HostAddress) +{ + // Set up socket params. + OrbisNetSockaddrIn addr = { 0 }; + addr.sin_family = ORBIS_NET_AF_INET; + addr.sin_addr.s_addr = HostAddress; + addr.sin_port = sceNetHtons(EVENT_PORT); + + // Create socket. + auto sock = sceNetSocket("SendEventSock", ORBIS_NET_AF_INET, ORBIS_NET_SOCK_STREAM, ORBIS_NET_IPPROTO_TCP); + + // Set connection time out to 4s. + int sock_timeout = 4000000; + sceNetSetsockopt(sock, ORBIS_NET_SOL_SOCKET, ORBIS_NET_SO_CONNECTTIMEO, &sock_timeout, sizeof(sock_timeout)); + + auto res = sceNetConnect(sock, (OrbisNetSockaddr*)&addr, sizeof(addr)); + if (!res) + return sock; + else + { + klog("Events::Connect() Error: %llX\n", res); + return NULL; + } +} + +void Events::SendEvent(int EventId, int pid) +{ + if (HostList.empty()) + return; + + for (const auto& host : HostList) + { + // Aquire a lock for the list. + scePthreadMutexLock(&HostListMutex); + + auto sock = Connect(host); + if (sock) + { + // Send EventId + Sockets::SendInt(sock, EventId); + + if (EventId == EVENT_ATTACH && pid != -1) + { + Sockets::SendInt(sock, pid); + } + + // Revoke the lock on the list. + scePthreadMutexUnlock(&HostListMutex); + } + else + { + // Revoke the lock on the list. + scePthreadMutexUnlock(&HostListMutex); + + RemoveHost(host); + } + } +} \ No newline at end of file diff --git a/Playstation/OrbisLibAPI/Events.h b/Playstation/OrbisLibAPI/Events.h new file mode 100644 index 0000000..1e4e2db --- /dev/null +++ b/Playstation/OrbisLibAPI/Events.h @@ -0,0 +1,31 @@ +#pragma once + +class Events +{ +public: + enum EventId + { + EVENT_EXCEPTION, + EVENT_CONTINUE, + EVENT_DIE, + EVENT_ATTACH, + EVENT_DETACH, + EVENT_SUSPEND, + EVENT_RESUME, + EVENT_SHUTDOWN, + }; + + static bool Init(); + static void Term(); + + static void AddHost(OrbisNetInAddr_t HostAddress); + static void RemoveHost(OrbisNetInAddr_t HostAddress); + static void SendEvent(int EventId, int pid = -1); + +private: + static std::vector< OrbisNetInAddr_t> HostList; + static OrbisPthreadMutex HostListMutex; + + static OrbisNetId Connect(OrbisNetInAddr_t HostAddress); +}; + diff --git a/Playstation/OrbisLibAPI/GeneralIPC.cpp b/Playstation/OrbisLibAPI/GeneralIPC.cpp index 2b8016b..d0f1d37 100644 --- a/Playstation/OrbisLibAPI/GeneralIPC.cpp +++ b/Playstation/OrbisLibAPI/GeneralIPC.cpp @@ -42,7 +42,7 @@ bool GeneralIPC::SendCommand(OrbisNetId Sock, int Command) return Status == GIPC_OK; } -bool GeneralIPC::GetLibraryList(int pid, std::vector& Libraries) +bool GeneralIPC::GetLibraryList(int pid, std::vector& Libraries) { // Open a new local socket connection for the process. auto sock = Connect(pid); @@ -70,7 +70,7 @@ bool GeneralIPC::GetLibraryList(int pid, std::vector& Libraries) // Resize the vector to accept the data. Libraries.resize(LibraryCount); - if (!Sockets::RecvLargeData(sock, (unsigned char*)Libraries.data(), LibraryCount * sizeof(LibraryInfo))) + if (!Sockets::RecvLargeData(sock, (unsigned char*)Libraries.data(), LibraryCount * sizeof(LibPacket))) { klog("[GeneralIPC] Failed to recv library data.\n"); return false; diff --git a/Playstation/OrbisLibAPI/GeneralIPC.h b/Playstation/OrbisLibAPI/GeneralIPC.h index d45a1fe..30fb403 100644 --- a/Playstation/OrbisLibAPI/GeneralIPC.h +++ b/Playstation/OrbisLibAPI/GeneralIPC.h @@ -8,7 +8,7 @@ private: static bool SendCommand(OrbisNetId Sock, int Command); public: - static bool GetLibraryList(int pid, std::vector& Libraries); + static bool GetLibraryList(int pid, std::vector& Libraries); static bool LoadLibrary(int pid, const char* Path, int* HandleOut); static bool UnLoadLibrary(int pid, int Handle); static bool Jailbreak(int pid); diff --git a/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj b/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj index 30c8168..0cf8919 100644 --- a/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj +++ b/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj @@ -67,6 +67,7 @@ del /s /q /f $(IntDir)\*.oelf + @@ -90,7 +91,9 @@ del /s /q /f $(IntDir)\*.oelf + + diff --git a/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj.filters b/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj.filters index df2edef..e449255 100644 --- a/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj.filters +++ b/Playstation/OrbisLibAPI/OrbisLibAPI.vcxproj.filters @@ -99,6 +99,9 @@ Source Files\Utilities + + Source Files\API + @@ -164,5 +167,11 @@ Header Files\Utilities + + Header Files + + + Header Files\API + \ No newline at end of file diff --git a/Playstation/OrbisLibAPI/SocketListener.cpp b/Playstation/OrbisLibAPI/SocketListener.cpp index f228a0e..f5eed43 100644 --- a/Playstation/OrbisLibAPI/SocketListener.cpp +++ b/Playstation/OrbisLibAPI/SocketListener.cpp @@ -1,19 +1,14 @@ #include "Common.h" #include "SocketListener.h" -struct ClientThreadParams -{ - SocketListener* socketListener; - OrbisNetId Sock; -}; - void* SocketListener::ClientThread(void* tdParam) { ClientThreadParams* Params = (ClientThreadParams*)tdParam; SocketListener* socketListener = Params->socketListener; OrbisNetId Sock = Params->Sock; + OrbisNetInAddr sin_addr = Params->sin_addr; - socketListener->ClientCallBack(socketListener->tdParam, Sock); + socketListener->ClientCallBack(socketListener->tdParam, Sock, sin_addr); sceNetSocketClose(Sock); free(Params); @@ -100,6 +95,7 @@ void* SocketListener::DoWork() ClientThreadParams* Params = new ClientThreadParams(); Params->socketListener = this; Params->Sock = ClientSocket; + Params->sin_addr = ClientAddr.sin_addr; // Create Thread to handle connection. OrbisPthread* Thread; @@ -132,7 +128,7 @@ void* SocketListener::ListenThread(void* tdParam) } -SocketListener::SocketListener(void(*ClientCallBack)(void* tdParam, OrbisNetId Sock), void* tdParam, unsigned short Port) +SocketListener::SocketListener(void(*ClientCallBack)(void* tdParam, OrbisNetId Sock, OrbisNetInAddr sin_addr), void* tdParam, unsigned short Port) { klog("Socket Listener.\n"); this->ClientCallBack = ClientCallBack; diff --git a/Playstation/OrbisLibAPI/SocketListener.h b/Playstation/OrbisLibAPI/SocketListener.h index 28de07a..8ff9621 100644 --- a/Playstation/OrbisLibAPI/SocketListener.h +++ b/Playstation/OrbisLibAPI/SocketListener.h @@ -15,10 +15,17 @@ private: void* DoWork(); static void* ClientThread(void* tdParam); void* tdParam; - void(*ClientCallBack)(void* tdParam, OrbisNetId Sock); + void(*ClientCallBack)(void* tdParam, OrbisNetId Sock, OrbisNetInAddr sin_addr); static void* ListenThread(void* tdParam); public: - SocketListener(void(*ClientCallBack)(void* tdParam, OrbisNetId Sock), void* tdParam, unsigned short Port); + struct ClientThreadParams + { + SocketListener* socketListener; + OrbisNetId Sock; + OrbisNetInAddr sin_addr; + }; + + SocketListener(void(*ClientCallBack)(void* tdParam, OrbisNetId Sock, OrbisNetInAddr sin_addr), void* tdParam, unsigned short Port); ~SocketListener(); }; \ No newline at end of file diff --git a/Playstation/OrbisLibAPI/Version.h b/Playstation/OrbisLibAPI/Version.h index a7c5037..da06592 100644 --- a/Playstation/OrbisLibAPI/Version.h +++ b/Playstation/OrbisLibAPI/Version.h @@ -1,11 +1,11 @@ -#pragma once -#define ORBISLIB_MAJOR 3 -#define ORBISLIB_MINOR 0 -#define ORBISLIB_BUILDVERSION 933 -#define stringify(a) stringify_(a) -#define stringify_(a) #a -#if defined(_DEBUG) -#define ORBISLIB_BUILDSTRING ("[OrbisLib Daemon " stringify(ORBISLIB_MAJOR) "." stringify(ORBISLIB_MINOR) "] Dev Build " stringify(ORBISLIB_BUILDVERSION) " " __DATE__ " " __TIME__) -#else -#define ORBISLIB_BUILDSTRING ("[OrbisLib Daemon " stringify(ORBISLIB_MAJOR) "." stringify(ORBISLIB_MINOR) "] Build " stringify(ORBISLIB_BUILDVERSION) " " __DATE__ " " __TIME__) -#endif +#pragma once +#define ORBISLIB_MAJOR 3 +#define ORBISLIB_MINOR 0 +#define ORBISLIB_BUILDVERSION 951 +#define stringify(a) stringify_(a) +#define stringify_(a) #a +#if defined(_DEBUG) +#define ORBISLIB_BUILDSTRING ("[OrbisLib Daemon " stringify(ORBISLIB_MAJOR) "." stringify(ORBISLIB_MINOR) "] Dev Build " stringify(ORBISLIB_BUILDVERSION) " " __DATE__ " " __TIME__) +#else +#define ORBISLIB_BUILDSTRING ("[OrbisLib Daemon " stringify(ORBISLIB_MAJOR) "." stringify(ORBISLIB_MINOR) "] Build " stringify(ORBISLIB_BUILDVERSION) " " __DATE__ " " __TIME__) +#endif diff --git a/Playstation/OrbisLibAPI/main.cpp b/Playstation/OrbisLibAPI/main.cpp index 14894bf..256c7c6 100644 --- a/Playstation/OrbisLibAPI/main.cpp +++ b/Playstation/OrbisLibAPI/main.cpp @@ -2,6 +2,7 @@ #include "Version.h" #include "API.h" #include "GoldHEN.h" +#include "Events.h" void exiting() { @@ -10,6 +11,9 @@ void exiting() // Terminate System Monitor SystemMonitor::Term(); + // Terminate the Events class. + Events::Term(); + // Terminate API API::Term(); @@ -47,6 +51,13 @@ int main() // Init a thread to monitor the system usage stats. // SystemMonitor::Init(); + if (!Events::Init()) + { + Notify("Failed to init Events..."); + sceSystemServiceLoadExec("exit", 0); + return 0; + } + // start up the API. NOTE: this is blocking. API::Init(); diff --git a/Playstation/OrbisLibGeneralHelper/OrbisLibGeneralHelper.cpp b/Playstation/OrbisLibGeneralHelper/OrbisLibGeneralHelper.cpp index 3a05eba..436b364 100644 --- a/Playstation/OrbisLibGeneralHelper/OrbisLibGeneralHelper.cpp +++ b/Playstation/OrbisLibGeneralHelper/OrbisLibGeneralHelper.cpp @@ -5,18 +5,35 @@ LocalSocketListener* LocalListener = nullptr; void SendLibraryList(OrbisNetId Sock) { + std::vector libraryList; + // Get the libraries. - LibraryInfo* LibraryList = (LibraryInfo*)malloc(200 * sizeof(LibraryInfo)); - int RealLibCount = jbc_get_proc_libraries(LibraryList, 200); + LibraryInfo* klibraryList = (LibraryInfo*)malloc(200 * sizeof(LibraryInfo)); + int realLibCount = jbc_get_proc_libraries(klibraryList, 200); // Send the Count - Sockets::SendInt(Sock, RealLibCount); + Sockets::SendInt(Sock, realLibCount); + + for (int i = 0; i < realLibCount; i++) + { + OrbisKernelModuleInfo moduleInfo; + moduleInfo.size = sizeof(OrbisKernelModuleInfo); + int res = sceKernelGetModuleInfo(klibraryList[i].Handle, &moduleInfo); + + LibPacket temp; + temp.Handle = klibraryList[i].Handle; + strcpy(temp.Path, klibraryList[i].Path); + temp.SegmentCount = moduleInfo.segmentCount; + memcpy(&temp.Segments[0], &moduleInfo.segmentInfo[0], sizeof(OrbisKernelModuleSegmentInfo) * 4); + + libraryList.push_back(temp); + } // Ship it. - Sockets::SendLargeData(Sock, (unsigned char*)LibraryList, RealLibCount * sizeof(LibraryInfo)); + Sockets::SendLargeData(Sock, (unsigned char*)libraryList.data(), realLibCount * sizeof(LibPacket)); // Clean up! - free(LibraryList); + free(klibraryList); } void LoadUnloadLib(int Command, OrbisNetId Sock) diff --git a/Windows/Libraries/OrbisLib2/Common/API/APIPackets.cs b/Windows/Libraries/OrbisLib2/Common/API/APIPackets.cs index 230213a..a880c67 100644 --- a/Windows/Libraries/OrbisLib2/Common/API/APIPackets.cs +++ b/Windows/Libraries/OrbisLib2/Common/API/APIPackets.cs @@ -201,7 +201,7 @@ namespace OrbisLib2.Common.API [StructLayout(LayoutKind.Sequential, Pack = 8, CharSet = CharSet.Ansi)] public struct LibraryPacket { - public long Handle; + public int Handle; [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string Path; public int SegmentCount; diff --git a/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherClient.cs b/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherClient.cs index 7b290bc..c16f493 100644 --- a/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherClient.cs +++ b/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherClient.cs @@ -34,51 +34,42 @@ namespace OrbisLib2.Common.Dispatcher Console.WriteLine("Invalid Packet..."); break; - // Debugging - case ForwardPacket.PacketType.Print: - TargetManager.SelectedTarget.Events.RaiseProcPrintEvent(Packet.SenderIPAddress, Packet.Print.Sender, Packet.Print.Data); - break; - case ForwardPacket.PacketType.SerialCom: // TODO: break; case ForwardPacket.PacketType.Intercept: - TargetManager.SelectedTarget.Events.RaiseProcInterceptEvent(Packet.SenderIPAddress); + Events.RaiseProcInterceptEvent(Packet.SenderIPAddress); break; case ForwardPacket.PacketType.Continue: - TargetManager.SelectedTarget.Events.RaiseProcContinueEvent(Packet.SenderIPAddress); + Events.RaiseProcContinueEvent(Packet.SenderIPAddress); break; // Process States case ForwardPacket.PacketType.ProcessDie: - TargetManager.SelectedTarget.Events.RaiseProcDieEvent(Packet.SenderIPAddress); + Events.RaiseProcDieEvent(Packet.SenderIPAddress); break; case ForwardPacket.PacketType.ProcessAttach: - TargetManager.SelectedTarget.Events.RaiseProcAttachEvent(Packet.SenderIPAddress, Packet.ProcessName); + Events.RaiseProcAttachEvent(Packet.SenderIPAddress, Packet.ProcessId); break; case ForwardPacket.PacketType.ProcessDetach: - TargetManager.SelectedTarget.Events.RaiseProcDetachEvent(Packet.SenderIPAddress); + Events.RaiseProcDetachEvent(Packet.SenderIPAddress); break; // Target State case ForwardPacket.PacketType.TargetSuspend: - TargetManager.SelectedTarget.Events.RaiseTargetSuspendEvent(Packet.SenderIPAddress); + Events.RaiseTargetSuspendEvent(Packet.SenderIPAddress); break; case ForwardPacket.PacketType.TargetResume: - TargetManager.SelectedTarget.Events.RaiseTargetResumeEvent(Packet.SenderIPAddress); + Events.RaiseTargetResumeEvent(Packet.SenderIPAddress); break; case ForwardPacket.PacketType.TargetShutdown: - TargetManager.SelectedTarget.Events.RaiseTargetShutdownEvent(Packet.SenderIPAddress); - break; - - case ForwardPacket.PacketType.TargetNewTitle: - TargetManager.SelectedTarget.Events.RaiseTargetNewTitleEvent(Packet.SenderIPAddress, Packet.TitleChange.TitleID); + Events.RaiseTargetShutdownEvent(Packet.SenderIPAddress); break; case ForwardPacket.PacketType.TargetAvailability: diff --git a/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherPackets.cs b/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherPackets.cs index 24c0451..e1701da 100644 --- a/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherPackets.cs +++ b/Windows/Libraries/OrbisLib2/Common/Dispatcher/DispatcherPackets.cs @@ -82,7 +82,6 @@ TargetSuspend, TargetResume, TargetShutdown, - TargetNewTitle, TargetAvailability, TargetAPIAvailability, @@ -101,9 +100,9 @@ public string? SenderIPAddress { get; set; } /// - /// Name of the process that the event was triggered for. + /// The process id for the event triggered. /// - public string? ProcessName { get; set; } + public int ProcessId { get; set; } public TitleChange? TitleChange { get; set; } diff --git a/Windows/Libraries/OrbisLib2/General/Events.cs b/Windows/Libraries/OrbisLib2/General/Events.cs index 7c0055a..80f940d 100644 --- a/Windows/Libraries/OrbisLib2/General/Events.cs +++ b/Windows/Libraries/OrbisLib2/General/Events.cs @@ -1,5 +1,90 @@ -namespace OrbisLib2.General +using OrbisLib2.Targets; + +namespace OrbisLib2.General { + public class ProcInterceptEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public ProcInterceptEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class ProcContinueEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public ProcContinueEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class ProcDieEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public ProcDieEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class ProcAttachEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public int NewProcessId { get; private set; } + + public ProcAttachEvent(Target SendingTarget, int NewProcessId) + { + this.SendingTarget = SendingTarget; + this.NewProcessId = NewProcessId; + } + } + + public class ProcDetachEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public ProcDetachEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class TargetSuspendEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public TargetSuspendEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class TargetResumeEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public TargetResumeEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + + public class TargetShutdownEvent : EventArgs + { + public Target SendingTarget { get; private set; } + + public TargetShutdownEvent(Target SendingTarget) + { + this.SendingTarget = SendingTarget; + } + } + public class DBTouchedEvent : EventArgs { public DBTouchedEvent() { } @@ -39,21 +124,166 @@ public class Events { + /// + /// Event fired when the current proccess the debugger is attached to thows an exception. + /// + public static event EventHandler ProcIntercept; + + /// + /// Event fired when the current proccess the debugger is attached to continues. + /// + public static event EventHandler ProcContinue; + + /// + /// Event fired when the current proccess the debugger is attached to is dying. + /// + public static event EventHandler ProcDie; + + /// + /// Event fired when the current proccess the debugger is attached to has changed. + /// + public static event EventHandler ProcAttach; + + /// + /// Event fired when debugging of the last attached process has stopped. + /// + public static event EventHandler ProcDetach; + + /// + /// Event fired when the corisponding target has changed states to suspend. + /// + public static event EventHandler TargetSuspend; + + /// + /// Event fired when the corisponding target has changed states to resume. + /// + public static event EventHandler TargetResume; + + /// + /// Event fired when the corisponding target has changed states to shutdown. + /// + public static event EventHandler TargetShutdown; + /// /// The DBTouched Event gets invoked when the Database used to store target specific info is changed. /// public static event EventHandler? DBTouched; /// - /// Even is fired when ever the state of the target changes. + /// Event is fired when ever the state of the target changes. /// public static event EventHandler? TargetStateChanged; /// - /// + /// Event thrown when ever the currently selected target has changed. /// public static event EventHandler? SelectedTargetChanged; + /// + /// Fires an event for when the Target's proccess were attached to has reached an intercepted state. + /// + /// The sending Target Address. + internal static void RaiseProcInterceptEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if(sendingTarget != null) + { + ProcIntercept?.Invoke(null, new ProcInterceptEvent(sendingTarget)); + } + } + + /// + /// Fires an event when a procees on the Target has gotten the signal to continue execution. + /// + /// The sending Target Address. + internal static void RaiseProcContinueEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + ProcContinue?.Invoke(null, new ProcContinueEvent(sendingTarget)); + } + } + + /// + /// Fires an event for when a proccess is going to be shutting down on the Target. + /// + /// The sending Target Address. + internal static void RaiseProcDieEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + ProcDie?.Invoke(null, new ProcDieEvent(sendingTarget)); + } + } + + /// + /// Fires an event for when the OrbisLib API attaches to a process. + /// + /// The sending Target Address. + /// The name of the process were attaching to. + internal static void RaiseProcAttachEvent(string IPAddr, int NewProcessId) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + ProcAttach?.Invoke(null, new ProcAttachEvent(sendingTarget, NewProcessId)); + } + } + + /// + /// Fires an event for when the OrbisLib API detaches to a process. + /// + /// The sending Target Address. + internal static void RaiseProcDetachEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + ProcDetach?.Invoke(null, new ProcDetachEvent(sendingTarget)); + } + } + + /// + /// Fires event for when Target is entering the suspended state. + /// + /// The sending Target Address. + internal static void RaiseTargetSuspendEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + TargetSuspend?.Invoke(null, new TargetSuspendEvent(sendingTarget)); + } + } + + /// + /// Fires event for when the Target is resuming from a suspended state. + /// + /// The sending Target Address. + internal static void RaiseTargetResumeEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + TargetResume?.Invoke(null, new TargetResumeEvent(sendingTarget)); + } + } + + /// + /// Fires an event for when the Target is shutting down. + /// + /// The sending Target Address. + internal static void RaiseTargetShutdownEvent(string IPAddr) + { + var sendingTarget = TargetManager.GetTarget(x => x.IPAddress == IPAddr); + if (sendingTarget != null) + { + TargetShutdown?.Invoke(null, new TargetShutdownEvent(sendingTarget)); + } + } + /// /// Will Fire the event for when the Database has been updated. /// diff --git a/Windows/Libraries/OrbisLib2/Targets/Target.cs b/Windows/Libraries/OrbisLib2/Targets/Target.cs index 2f58edf..7fd30ad 100644 --- a/Windows/Libraries/OrbisLib2/Targets/Target.cs +++ b/Windows/Libraries/OrbisLib2/Targets/Target.cs @@ -80,7 +80,6 @@ namespace OrbisLib2.Targets } } - public TargetEvents Events; public Debug Debug; public Payload Payload; public Process Process; @@ -91,7 +90,6 @@ namespace OrbisLib2.Targets { _SavedTargetId = SavedTarget.Id; - Events = new TargetEvents(this); Debug = new Debug(this); Payload = new Payload(this); Process = new Process(this); diff --git a/Windows/Libraries/OrbisLib2/Targets/TargetEvents.cs b/Windows/Libraries/OrbisLib2/Targets/TargetEvents.cs deleted file mode 100644 index 4c10be1..0000000 --- a/Windows/Libraries/OrbisLib2/Targets/TargetEvents.cs +++ /dev/null @@ -1,205 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace OrbisLib2.Targets -{ - public class PrintEvent : EventArgs - { - public string Sender { get; private set; } - public string Data { get; private set; } - - public PrintEvent(string Sender, string Data) - { - this.Sender = Sender; - this.Data = Data; - } - } - - public class ProcInterceptEvent : EventArgs - { - public ProcInterceptEvent() - { - - } - } - - public class ProcContinueEvent : EventArgs - { - public ProcContinueEvent() { } - } - - public class ProcDieEvent : EventArgs - { - public ProcDieEvent() { } - } - - public class ProcAttachEvent : EventArgs - { - public string NewProcName { get; private set; } - - public ProcAttachEvent(string NewProcName) - { - this.NewProcName = NewProcName; - } - } - - public class ProcDetachEvent : EventArgs - { - public ProcDetachEvent() { } - } - - public class TargetSuspendEvent : EventArgs - { - public TargetSuspendEvent() { } - } - - public class TargetResumeEvent : EventArgs - { - public TargetResumeEvent() { } - } - - public class TargetShutdownEvent : EventArgs - { - public TargetShutdownEvent() { } - } - - public class TargetNewTitleEvent : EventArgs - { - public string TitleID { get; private set; } - - public TargetNewTitleEvent(string TitleID) - { - this.TitleID = TitleID; - } - } - - public class TargetEvents - { - private Target Target; - - public event EventHandler Print; - public event EventHandler ProcIntercept; - public event EventHandler ProcContinue; - public event EventHandler ProcDie; - public event EventHandler ProcAttach; - public event EventHandler ProcDetach; - public event EventHandler TargetSuspend; - public event EventHandler TargetResume; - public event EventHandler TargetShutdown; - public event EventHandler TargetNewTitle; - - public TargetEvents(Target Target) - { - this.Target = Target; - } - - /// - /// Event that should be fired when we recieve a print from the remote target. - /// - /// The sending Target Address. - /// - /// - internal void RaiseProcPrintEvent(string SenderIPAddress, string Sender, string Data) - { - if (SenderIPAddress.Equals(Target.IPAddress)) - Print?.Invoke(null, new PrintEvent(Sender, Data)); - } - - /// - /// Fires an event for when the Target's proccess were attached to has reached an intercepted state. - /// - /// The sending Target Address. - internal void RaiseProcInterceptEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - { - ProcIntercept?.Invoke(null, new ProcInterceptEvent()); - } - } - - /// - /// Fires an event when a procees on the Target has gotten the signal to continue execution. - /// - /// The sending Target Address. - internal void RaiseProcContinueEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - ProcContinue?.Invoke(null, new ProcContinueEvent()); - } - - /// - /// Fires an event for when a proccess is going to be shutting down on the Target. - /// - /// The sending Target Address. - internal void RaiseProcDieEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - ProcDie?.Invoke(null, new ProcDieEvent()); - } - - /// - /// Fires an event for when the OrbisLib API attaches to a process. - /// - /// The sending Target Address. - /// The name of the process were attaching to. - internal void RaiseProcAttachEvent(string IPAddr, string NewProcName) - { - if (IPAddr.Equals(Target.IPAddress)) - ProcAttach?.Invoke(null, new ProcAttachEvent(NewProcName)); - } - - /// - /// Fires an event for when the OrbisLib API detaches to a process. - /// - /// The sending Target Address. - internal void RaiseProcDetachEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - ProcDetach?.Invoke(null, new ProcDetachEvent()); - } - - /// - /// Fires event for when Target is entering the suspended state. - /// - /// The sending Target Address. - internal void RaiseTargetSuspendEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - TargetSuspend?.Invoke(null, new TargetSuspendEvent()); - } - - /// - /// Fires event for when the Target is resuming from a suspended state. - /// - /// The sending Target Address. - internal void RaiseTargetResumeEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - TargetResume?.Invoke(null, new TargetResumeEvent()); - } - - /// - /// Fires an event for when the Target is shutting down. - /// - /// The sending Target Address. - internal void RaiseTargetShutdownEvent(string IPAddr) - { - if (IPAddr.Equals(Target.IPAddress)) - TargetShutdown?.Invoke(null, new TargetShutdownEvent()); - } - - /// - /// Fires an event for when we change the current game on the Target. - /// - /// The sending Target Address. - /// The next title index our Target will be running. - internal void RaiseTargetNewTitleEvent(string IPAddr, string TitleID) - { - if (IPAddr.Equals(Target.IPAddress)) - TargetNewTitle?.Invoke(null, new TargetNewTitleEvent(TitleID)); - } - } -} diff --git a/Windows/Libraries/OrbisLib2/Targets/TargetManager.cs b/Windows/Libraries/OrbisLib2/Targets/TargetManager.cs index 52278c8..e50aa99 100644 --- a/Windows/Libraries/OrbisLib2/Targets/TargetManager.cs +++ b/Windows/Libraries/OrbisLib2/Targets/TargetManager.cs @@ -3,6 +3,7 @@ using OrbisLib2.Common.Database; using OrbisLib2.Common.Database.Types; using OrbisLib2.Common.Helpers; using OrbisLib2.General; +using System.Linq.Expressions; using System.Runtime.InteropServices; namespace OrbisLib2.Targets @@ -65,7 +66,6 @@ namespace OrbisLib2.Targets /// Gets the specified target by name. /// /// The specified target name. - /// Target output. /// Returns true if target is found. public static Target? GetTarget(string TargetName) { @@ -79,6 +79,23 @@ namespace OrbisLib2.Targets return new Target(saveedTarget); } + /// + /// Gets the specified target by predicate. + /// + /// The predicate to be used to find the target. + /// + public static Target? GetTarget(Expression> predicate) + { + var saveedTarget = SavedTarget.FindTarget(predicate); + + if (saveedTarget == null) + { + return null; + } + + return new Target(saveedTarget); + } + /// /// Deletes the specified target. /// diff --git a/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml b/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml index 2a2a245..ce52bdc 100644 --- a/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml +++ b/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml @@ -180,7 +180,7 @@ - + diff --git a/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml.cs b/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml.cs index 4e0d97e..fe4fc0b 100644 --- a/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml.cs +++ b/Windows/OrbisLibraryManager/OrbisLibraryManager.xaml.cs @@ -1,6 +1,8 @@ using OrbisLib2.Common.Dispatcher; +using OrbisLib2.General; using OrbisLib2.Targets; using SimpleUI.Controls; +using System; using System.Threading.Tasks; using System.Windows; @@ -15,6 +17,25 @@ namespace OrbisLibraryManager { InitializeComponent(); DispatcherClient.Subscribe(); + + Events.ProcAttach += Events_ProcAttach; + Events.ProcDetach += Events_ProcDetach; + } + + private void Events_ProcDetach(object? sender, ProcDetachEvent e) + { + if(e.SendingTarget.IPAddress == TargetManager.SelectedTarget.IPAddress) + { + Console.WriteLine("ProcDetach"); + } + } + + private void Events_ProcAttach(object? sender, ProcAttachEvent e) + { + if (e.SendingTarget.IPAddress == TargetManager.SelectedTarget.IPAddress) + { + Console.WriteLine($"ProcAttach {e.NewProcessId}"); + } } private void RefreshLibraryList() diff --git a/Windows/OrbisNeighborHood/Resources/BuildNumber.txt b/Windows/OrbisNeighborHood/Resources/BuildNumber.txt index 2612554..d61563f 100644 --- a/Windows/OrbisNeighborHood/Resources/BuildNumber.txt +++ b/Windows/OrbisNeighborHood/Resources/BuildNumber.txt @@ -1 +1 @@ -2313 +2336 diff --git a/Windows/OrbisNeighborHood/Resources/BuildString.txt b/Windows/OrbisNeighborHood/Resources/BuildString.txt index 283a30e..b72e2a4 100644 --- a/Windows/OrbisNeighborHood/Resources/BuildString.txt +++ b/Windows/OrbisNeighborHood/Resources/BuildString.txt @@ -1 +1 @@ -Version 3.0.2313 Debug Build Wednesday January 04 2023 8:32 PM +Version 3.0.2336 Debug Build Friday January 06 2023 10:36 PM diff --git a/Windows/OrbisSuiteService/Service/Dispatcher.cs b/Windows/OrbisSuiteService/Service/Dispatcher.cs index aa697c4..033485d 100644 --- a/Windows/OrbisSuiteService/Service/Dispatcher.cs +++ b/Windows/OrbisSuiteService/Service/Dispatcher.cs @@ -13,7 +13,8 @@ namespace OrbisSuiteService.Service private Settings _Settings = Settings.CreateInstance(); //private SerialComHelper _SerialMonitor = new SerialComHelper(); private TargetWatcher _TargetWatcher; - + private TargetEventListener _TargetEventListener; + public Dispatcher() { @@ -25,6 +26,7 @@ namespace OrbisSuiteService.Service _SerialMonitor.Settings.PortName = ""; _SerialMonitor.StartListening();*/ _TargetWatcher = new TargetWatcher(this); + _TargetEventListener = new TargetEventListener(this); } private byte[] _SerialDataBuffer = new byte[0]; diff --git a/Windows/OrbisSuiteService/Service/TargetEventListener.cs b/Windows/OrbisSuiteService/Service/TargetEventListener.cs new file mode 100644 index 0000000..24342c2 --- /dev/null +++ b/Windows/OrbisSuiteService/Service/TargetEventListener.cs @@ -0,0 +1,83 @@ +using OrbisLib2.Common; +using OrbisLib2.Common.Helpers; +using System.Net.Sockets; +using OrbisLib2.Common.Dispatcher; +using System.Windows.Threading; +using System.Net; +using System.Text; + +namespace OrbisSuiteService.Service +{ + public enum EventId + { + EVENT_EXCEPTION, + EVENT_CONTINUE, + EVENT_DIE, + EVENT_ATTACH, + EVENT_DETACH, + EVENT_SUSPEND, + EVENT_RESUME, + EVENT_SHUTDOWN, + }; + + public class TargetEventListener + { + private Listener _TargetListener; + private Dispatcher _Dispatcher; + + public TargetEventListener(Dispatcher Dispatcher) + { + _Dispatcher = Dispatcher; + + _TargetListener = new Listener(Config.EventPort); + _TargetListener.SocketAccepted += _TargetListener_SocketAccepted; + _TargetListener.Start(); + } + + private void _TargetListener_SocketAccepted(Socket s) + { + var eventId = s.RecvInt32(); + var ipAddress = ((IPEndPoint)s.RemoteEndPoint).Address.ToString(); + switch (eventId) + { + default: + Console.WriteLine($"Unknown Event {eventId}\n"); + break; + + case (int)EventId.EVENT_EXCEPTION: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.Intercept, ipAddress)); + break; + + case (int)EventId.EVENT_CONTINUE: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.Continue, ipAddress)); + break; + + case (int)EventId.EVENT_DIE: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.ProcessDie, ipAddress)); + break; + + case (int)EventId.EVENT_ATTACH: + var packet = new ForwardPacket(ForwardPacket.PacketType.ProcessAttach, ipAddress); + packet.ProcessId = s.RecvInt32(); + _Dispatcher.PublishEvent(packet); + break; + + case (int)EventId.EVENT_DETACH: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.ProcessDetach, ipAddress)); + break; + + case (int)EventId.EVENT_SUSPEND: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.TargetSuspend, ipAddress)); + break; + + case (int)EventId.EVENT_RESUME: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.TargetResume, ipAddress)); + break; + + case (int)EventId.EVENT_SHUTDOWN: + _Dispatcher.PublishEvent(new ForwardPacket(ForwardPacket.PacketType.TargetShutdown, ipAddress)); + break; + } + } + } +}