fix issues

libpsutil/network/httpclient.cpp

@@ -12,21 +12,24 @@ namespace libpsutil
 			auto* host = gethostbyname(url.data());
 			auto ip = *((uint32_t*)host->h_addr);
 
-			socket* http = new socket(ip, port);
-
 			size_t pos = 0;
 			std::string space = " ";
 			while ((pos = query.find(space, pos)) != std::string::npos)
 				query.replace(pos, space.length(), "%20");
 
 			char response[1024] = { 0 };
 			char request[1024] = { 0 };
-			sprintf(request, "GET %s HTTP/1.1\nHost: localhost\nContent-Length: 1024\n\r\n\r\n", query.data());
+			sprintf(request, "GET %s HTTP/1.1\nHost: %s\r\n\r\n", query.data(), url.data());
 
-			auto success = http->send(request, 1024);
+			socket* http = new socket(ip, port);
+			auto success = http->connect();
 			if (success)
 			{
-				success = http->receive(response, 1024);
+				success = http->send(request, strlen(request) + 1);
+				if (success)
+				{
+					success = http->receive(response, 1024);
+				}
 			}
 
 			http->close();

libpsutil/network/socket.cpp

@@ -117,7 +117,7 @@ namespace libpsutil
 				}
 
 				int chunk = min(2048, data_remaining);
-				if (this->type_ == SOCKET_TYPE_TCP)
+				if (this->type_ == socket_type::SOCKET_TYPE_TCP)
 				{
 					recv_length = ::recv(this->socket_, current_position, chunk, 0);
 				}
@@ -132,6 +132,10 @@ namespace libpsutil
 					printf("[Socket]: Receive failed\n");
 					return false;
 				}
+				else if (recv_length < chunk)
+				{
+					return true;
+				}
 
 				data_remaining -= recv_length;
 				current_position += recv_length;
@@ -162,7 +166,7 @@ namespace libpsutil
 				}
 
 				int chunk = min(2048, data_remaining);
-				if (this->type_ == SOCKET_TYPE_TCP)
+				if (this->type_ == socket_type::SOCKET_TYPE_TCP)
 				{
 					send_length = ::send(this->socket_, current_position, chunk, 0);
 				}
@@ -176,6 +180,10 @@ namespace libpsutil
 					printf("[Socket]: Send failed\n");
 					return false;
 				}
+				else if (send_length < chunk)
+				{
+					return true;
+				}
 
 				data_remaining -= send_length;
 				current_position += send_length;

libpsutil/system/memory.cpp

@@ -2,6 +2,7 @@
 #include <sys/return_code.h>
 #include "system/memory.hpp"
 #include "system/syscalls.hpp"
+#include "system/imports.hpp"
 
 namespace libpsutil
 {
@@ -13,19 +14,19 @@ namespace libpsutil
 
 		bool get(uint32_t address, void* data, size_t length)
 		{
-			return sys_dbg_read_process_memory(address, data, length) == SUCCEEDED;
+			return read_process_memory(address, data, length) == SUCCEEDED;
 		}
 
 		bool get(uint32_t address, std::vector<uint8_t>& bytes, size_t length)
 		{
 			bytes.resize(length);
 			uint8_t* buffer = &bytes[0];
-			return sys_dbg_read_process_memory(address, buffer, length) == SUCCEEDED;
+			return read_process_memory(address, buffer, length) == SUCCEEDED;
 		}
 
 		bool set(uint32_t address, void* data, size_t length)
 		{
-			return sys_dbg_write_process_memory(address, data, length) == SUCCEEDED;
+			return write_process_memory(address, data, length) == SUCCEEDED;
 		}
 
 		bool nop(uint32_t address)
@@ -85,19 +86,19 @@ namespace libpsutil
 			detour::force_stub_addr = address;
 		}
 
-		detour::detour(uint32_t address, void(*destination))
+		void detour::setup_detour(uint32_t address, void *destination)
 		{
 			if (address == NULL) { return; }
 
+			memcpy(this->original_instructions, reinterpret_cast<void*>(address), 0x10);
+
 			this->address = reinterpret_cast<uint32_t*>(address);
 			auto* stub_address = reinterpret_cast<uint32_t*>(this->allocate_stub());
 
-			memcpy(this->original_instructions, reinterpret_cast<void*>(address), 0x10);
-
 			uint32_t instruction_count = 0;
 			for (int i = 0; i < 4; i++)
 			{
-				const auto current_address = reinterpret_cast<uint32_t>(&stub_address[instruction_count]);
+				auto current_address = reinterpret_cast<uint32_t>(&stub_address[instruction_count]);
 				if ((this->address[i] & 0xF8000000) == 0x48000000)
 				{
 					memory::jump(current_address, this->resolve_branch(this->address[i], (int)&this->address[i]), true);
@@ -111,7 +112,7 @@ namespace libpsutil
 			}
 
 			memory::jump(reinterpret_cast<uint32_t>(&stub_address[instruction_count]), address + 0x10, false);
-			memory::jump(address, reinterpret_cast<uint32_t>(destination), false);
+			memory::jump(address, *reinterpret_cast<uint32_t*>(destination), false);
 
 			this->stub_opd[0] = reinterpret_cast<uint32_t>(stub_address);
 			this->stub_opd[1] = memory::get_game_toc();

libpsutil/system/memory.hpp

@@ -74,14 +74,19 @@ namespace libpsutil
 
 			uint32_t allocate_stub();
 			uint32_t resolve_branch(uint32_t instruction, uint32_t branch_address);
+			void setup_detour(uint32_t address, void* destination);
 
 		public:
-			detour(uint32_t address, void(*destination));
+			template<class T> detour(uint32_t address, T(*destination))
+			{
+				this->setup_detour(address, reinterpret_cast<void*>(destination));
+			}
+
 			~detour();
 
 			static void force_stub_address(uint32_t address);
 
-			template<typename T, typename... params> T invoke(params... parameters)
+			template<typename T = void, typename... params> T invoke(params... parameters)
 			{
 				T(*original)(params...) = (T(*)(params...))this->stub_opd;
 				return original(parameters...);

libpsutil/system/syscalls.cpp

@@ -1,21 +1,66 @@
+#include <ppu_intrinsics.h>
 #include <sys/process.h>
 #include <sys/syscall.h>
 #include "system/syscalls.hpp"
 
 namespace libpsutil
 {
-	uint32_t sys_dbg_read_process_memory(uint64_t address, void* data, size_t size)
+	bool use_hen_syscalls = false;
+
+	uint32_t sys_hen_read_process_memory(uint64_t address, void* data, size_t size)
 	{
 		system_call_6(8, 0x7777, 0x31, (uint64_t)sys_process_getpid(), address, (uint64_t)data, size);
 		return_to_user_prog(uint32_t);
 	}
 
-	uint32_t sys_dbg_write_process_memory(uint64_t address, void* data, size_t size)
+	uint32_t sys_hen_write_process_memory(uint64_t address, void* data, size_t size)
 	{
 		system_call_6(8, 0x7777, 0x32, (uint64_t)sys_process_getpid(), address, (uint64_t)data, size);
 		return_to_user_prog(uint32_t);
 	}
 
+	uint32_t sys_dbg_read_process_memory(uint64_t address, void* data, size_t size)
+	{
+		system_call_4(904, (uint64_t)sys_process_getpid(), address, size, (uint64_t)data);
+		return_to_user_prog(uint32_t);
+	}
+
+	uint32_t sys_dbg_write_process_memory(uint64_t address, void* data, size_t size)
+	{
+		system_call_4(905, (uint64_t)sys_process_getpid(), address, size, (uint64_t)data);
+		return_to_user_prog(uint32_t);
+	}
+
+	uint32_t read_process_memory(uint64_t address, void* data, size_t size)
+	{
+		if (!use_hen_syscalls)
+		{
+			uint32_t read = sys_dbg_read_process_memory(address, data, size);
+			if (read == SUCCEEDED)
+			{
+				return read;
+			}
+		}
+
+		use_hen_syscalls = true;
+		return sys_hen_read_process_memory(address, data, size);
+	}
+
+	uint32_t write_process_memory(uint64_t address, void* data, size_t size)
+	{
+		if (!use_hen_syscalls)
+		{
+			uint32_t write = sys_dbg_write_process_memory(address, data, size);
+			if (write == SUCCEEDED)
+			{
+				return write;
+			}
+		}
+
+		use_hen_syscalls = true;
+		return sys_hen_write_process_memory(address, data, size);
+	}
+
 	void sleep(uint64_t milliseconds)
 	{
 		system_call_1(SYS_TIMER_USLEEP, milliseconds * 1000);

libpsutil/system/syscalls.hpp

@@ -4,7 +4,7 @@
 
 namespace libpsutil
 {
-	uint32_t sys_dbg_read_process_memory(uint64_t address, void* data, size_t size);
-	uint32_t sys_dbg_write_process_memory(uint64_t address, void* data, size_t size);
+	uint32_t read_process_memory(uint64_t address, void* data, size_t size);
+	uint32_t write_process_memory(uint64_t address, void* data, size_t size);
 	void sleep(uint64_t milliseconds);
 }