From b997b33d584cd48da802f8b5d9ddd8f5eb1ad7df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Wed, 6 Aug 2025 00:23:08 +0200 Subject: [PATCH 1/4] Change hardcoded F8 shortcut key to only work in debugger window. If desired, this can be manually re-mapped (as "Pause (no menu)") to restore the old functionality Fixes #20676 --- Windows/ppsspp.rc | 2 -- 1 file changed, 2 deletions(-) diff --git a/Windows/ppsspp.rc b/Windows/ppsspp.rc index 37d8c9c263..21ee3ce040 100644 --- a/Windows/ppsspp.rc +++ b/Windows/ppsspp.rc @@ -70,7 +70,6 @@ BEGIN VK_F4, ID_FILE_QUICKLOADSTATE_HC, VIRTKEY, NOINVERT "1", ID_OPTIONS_RESOLUTIONDUMMY, VIRTKEY, CONTROL, NOINVERT VK_F12, ID_DEBUG_TAKESCREENSHOT, VIRTKEY, NOINVERT - VK_F8, ID_TOGGLE_BREAK, VIRTKEY, NOINVERT VK_RETURN, ID_OPTIONS_FULLSCREEN, ALT, VIRTKEY, NOINVERT VK_F11, ID_OPTIONS_FULLSCREEN, VIRTKEY, NOINVERT END @@ -85,7 +84,6 @@ BEGIN "2", ID_DEBUG_DISPLAYBREAKPOINTLIST, VIRTKEY, CONTROL, NOINVERT "3", ID_DEBUG_DISPLAYTHREADLIST, VIRTKEY, CONTROL, NOINVERT "4", ID_DEBUG_DISPLAYSTACKFRAMELIST, VIRTKEY, CONTROL, NOINVERT - VK_F7, ID_TOGGLE_BREAK, VIRTKEY, NOINVERT VK_F8, ID_DEBUG_STEPOUT, VIRTKEY, NOINVERT VK_F9, ID_DEBUG_RUNTOLINE, VIRTKEY, NOINVERT VK_F10, ID_DEBUG_STEPOVER, VIRTKEY, NOINVERT From 3e2dce1e543e9249f5ed1738f6730620274c723b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Wed, 6 Aug 2025 00:41:08 +0200 Subject: [PATCH 2/4] Move AdHoc error codes to the big enum, fix the naming convention to be consistent --- Core/HLE/ErrorCodes.h | 80 ++++++ Core/HLE/proAdhoc.cpp | 3 +- Core/HLE/proAdhoc.h | 82 ------ Core/HLE/sceKernel.cpp | 81 ++++++ Core/HLE/sceNet.cpp | 2 +- Core/HLE/sceNetAdhoc.cpp | 416 +++++++++++++++---------------- Core/HLE/sceNetAdhocMatching.cpp | 118 ++++----- 7 files changed, 431 insertions(+), 351 deletions(-) diff --git a/Core/HLE/ErrorCodes.h b/Core/HLE/ErrorCodes.h index dabc91dc30..f917f16d51 100644 --- a/Core/HLE/ErrorCodes.h +++ b/Core/HLE/ErrorCodes.h @@ -552,4 +552,84 @@ enum PSPErrorCode : u32 { SCE_NET_APCTL_ERROR_INVALID_ID = 0x80410a09, SCE_NET_APCTL_ERROR_WLAN_SUSPENDED = 0x80410a0a, SCE_NET_APCTL_ERROR_TIMEOUT = 0x80410a0b, + + // pspnet_adhoc_auth + SCE_NET_ADHOC_ERROR_AUTH_ALREADY_INITIALIZED = 0x80410601, + + // pspnet_adhoc + SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID = 0x80410701, + SCE_NET_ADHOC_ERROR_INVALID_ADDR = 0x80410702, + SCE_NET_ADHOC_ERROR_INVALID_PORT = 0x80410703, + SCE_NET_ADHOC_ERROR_INVALID_BUFLEN = 0x80410704, + SCE_NET_ADHOC_ERROR_INVALID_DATALEN = 0x80410705, + SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE = 0x80400706, // not a typo + SCE_NET_ADHOC_ERROR_SOCKET_DELETED = 0x80410707, + SCE_NET_ADHOC_ERROR_SOCKET_ALERTED = 0x80410708, + SCE_NET_ADHOC_ERROR_WOULD_BLOCK = 0x80410709, //ERROR_NET_ADHOC_NO_DATA_AVAILABLE + SCE_NET_ADHOC_ERROR_PORT_IN_USE = 0x8041070a, + SCE_NET_ADHOC_ERROR_NOT_CONNECTED = 0x8041070B, + SCE_NET_ADHOC_ERROR_DISCONNECTED = 0x8041070c, + SCE_NET_ADHOC_ERROR_NOT_OPENED = 0x8040070D, // not a typo + SCE_NET_ADHOC_ERROR_NOT_LISTENED = 0x8040070E, // not a typo + SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL = 0x8041070F, + SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL = 0x80410710, + SCE_NET_ADHOC_ERROR_INVALID_ARG = 0x80410711, + SCE_NET_ADHOC_ERROR_NOT_INITIALIZED = 0x80410712, + SCE_NET_ADHOC_ERROR_ALREADY_INITIALIZED = 0x80410713, + SCE_NET_ADHOC_ERROR_BUSY = 0x80410714, + SCE_NET_ADHOC_ERROR_TIMEOUT = 0x80410715, + SCE_NET_ADHOC_ERROR_NO_ENTRY = 0x80410716, + SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT = 0x80410717, + SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED = 0x80410718, + SCE_NET_ADHOC_ERROR_THREAD_ABORTED = 0x80410719, + SCE_NET_ADHOC_ERROR_ALREADY_CREATED = 0x8041071A, + SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE = 0x8041071B, + SCE_NET_ADHOC_ERROR_NOT_CREATED = 0x8041071C, + + // pspnet_adhoc_matching + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MODE = 0x80410801, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_PORT = 0x80410802, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MAXNUM = 0x80410803, + SCE_NET_ADHOC_MATCHING_ERROR_RXBUF_TOO_SHORT = 0x80410804, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN = 0x80410805, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG = 0x80410806, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID = 0x80410807, + SCE_NET_ADHOC_MATCHING_ERROR_ID_NOT_AVAIL = 0x80410808, + SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE = 0x80410809, + SCE_NET_ADHOC_MATCHING_ERROR_IS_RUNNING = 0x8041080A, + SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING = 0x8041080B, + SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET = 0x8041080C, + SCE_NET_ADHOC_MATCHING_ERROR_TARGET_NOT_READY = 0x8041080D, + SCE_NET_ADHOC_MATCHING_ERROR_EXCEED_MAXNUM = 0x8041080E, + SCE_NET_ADHOC_MATCHING_ERROR_REQUEST_IN_PROGRESS = 0x8041080F, + SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED = 0x80410810, + SCE_NET_ADHOC_MATCHING_ERROR_BUSY = 0x80410811, + SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_INITIALIZED = 0x80410812, + SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED = 0x80410813, + SCE_NET_ADHOC_MATCHING_ERROR_PORT_IN_USE = 0x80410814, + SCE_NET_ADHOC_MATCHING_ERROR_STACKSIZE_TOO_SHORT = 0x80410815, + SCE_NET_ADHOC_MATCHING_ERROR_INVALID_DATALEN = 0x80410816, + SCE_NET_ADHOC_MATCHING_ERROR_NOT_ESTABLISHED = 0x80410817, + SCE_NET_ADHOC_MATCHING_ERROR_DATA_BUSY = 0x80410818, + + // pspnet_adhocctl + SCE_NET_ADHOCCTL_ERROR_NOT_LEFT_IBSS = 0x80410b01, + SCE_NET_ADHOCCTL_ERROR_ALREADY_CONNECTED = 0x80410b02, + SCE_NET_ADHOCCTL_ERROR_WLAN_SWITCH_OFF = 0x80410b03, + SCE_NET_ADHOCCTL_ERROR_INVALID_ARG = 0x80410B04, + SCE_NET_ADHOCCTL_ERROR_TIMEOUT = 0x80410b05, + SCE_NET_ADHOCCTL_ERROR_ID_NOT_FOUND = 0x80410B06, + SCE_NET_ADHOCCTL_ERROR_ALREADY_INITIALIZED = 0x80410b07, + SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED = 0x80410b08, + SCE_NET_ADHOCCTL_ERROR_DISCONNECTED = 0x80410b09, + SCE_NET_ADHOCCTL_ERROR_NO_SCAN_INFO = 0x80410b0a, + SCE_NET_ADHOCCTL_ERROR_INVALID_IBSS = 0x80410b0b, + SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE = 0x80410B0C, + SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_AVAILABLE = 0x80410B0D, + SCE_NET_ADHOCCTL_ERROR_WLAN_BEACON_LOST = 0x80410b0e, + SCE_NET_ADHOCCTL_ERROR_WLAN_SUSPENDED = 0x80410b0f, + SCE_NET_ADHOCCTL_ERROR_BUSY = 0x80410b10, + SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_MATCH = 0x80410b11, + SCE_NET_ADHOCCTL_ERROR_TOO_MANY_HANDLERS = 0x80410b12, + SCE_NET_ADHOCCTL_ERROR_STACKSIZE_TOO_SHORT = 0x80410B13, }; diff --git a/Core/HLE/proAdhoc.cpp b/Core/HLE/proAdhoc.cpp index 1afa6b0731..1cadee5e13 100644 --- a/Core/HLE/proAdhoc.cpp +++ b/Core/HLE/proAdhoc.cpp @@ -41,6 +41,7 @@ #include "Core/HLE/sceKernel.h" #include "Core/HLE/sceKernelMutex.h" #include "Core/HLE/sceUtility.h" +#include "Core/HLE/ErrorCodes.h" #include "Core/MemMap.h" #include "Core/HLE/HLE.h" @@ -1454,7 +1455,7 @@ int friendFinder() { // Calculate EnterGameMode Timeout to prevent waiting forever for disconnected players if (isAdhocctlBusy && adhocctlState == ADHOCCTL_STATE_DISCONNECTED && adhocctlCurrentMode == ADHOCCTL_MODE_GAMEMODE && netAdhocGameModeEntered && static_cast(now - adhocctlStartTime) > netAdhocEnterGameModeTimeout) { netAdhocGameModeEntered = false; - notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, ERROR_NET_ADHOC_TIMEOUT); + notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, SCE_NET_ADHOC_ERROR_TIMEOUT); } // Handle Packets diff --git a/Core/HLE/proAdhoc.h b/Core/HLE/proAdhoc.h index be9d80989d..f45c213182 100644 --- a/Core/HLE/proAdhoc.h +++ b/Core/HLE/proAdhoc.h @@ -519,88 +519,6 @@ typedef struct SceNetAdhocMatchingContext { // End of psp definitions -enum { - // pspnet_adhoc_auth - ERROR_NET_ADHOC_AUTH_ALREADY_INITIALIZED = 0x80410601, - - // pspnet_adhoc - ERROR_NET_ADHOC_INVALID_SOCKET_ID = 0x80410701, - ERROR_NET_ADHOC_INVALID_ADDR = 0x80410702, - ERROR_NET_ADHOC_INVALID_PORT = 0x80410703, - ERROR_NET_ADHOC_INVALID_BUFLEN = 0x80410704, - ERROR_NET_ADHOC_INVALID_DATALEN = 0x80410705, - ERROR_NET_ADHOC_NOT_ENOUGH_SPACE = 0x80400706, // not a typo - ERROR_NET_ADHOC_SOCKET_DELETED = 0x80410707, - ERROR_NET_ADHOC_SOCKET_ALERTED = 0x80410708, - ERROR_NET_ADHOC_WOULD_BLOCK = 0x80410709, //ERROR_NET_ADHOC_NO_DATA_AVAILABLE - ERROR_NET_ADHOC_PORT_IN_USE = 0x8041070a, - ERROR_NET_ADHOC_NOT_CONNECTED = 0x8041070B, - ERROR_NET_ADHOC_DISCONNECTED = 0x8041070c, - ERROR_NET_ADHOC_NOT_OPENED = 0x8040070D, // not a typo - ERROR_NET_ADHOC_NOT_LISTENED = 0x8040070E, // not a typo - ERROR_NET_ADHOC_SOCKET_ID_NOT_AVAIL = 0x8041070F, - ERROR_NET_ADHOC_PORT_NOT_AVAIL = 0x80410710, - ERROR_NET_ADHOC_INVALID_ARG = 0x80410711, - ERROR_NET_ADHOC_NOT_INITIALIZED = 0x80410712, - ERROR_NET_ADHOC_ALREADY_INITIALIZED = 0x80410713, - ERROR_NET_ADHOC_BUSY = 0x80410714, - ERROR_NET_ADHOC_TIMEOUT = 0x80410715, - ERROR_NET_ADHOC_NO_ENTRY = 0x80410716, - ERROR_NET_ADHOC_EXCEPTION_EVENT = 0x80410717, - ERROR_NET_ADHOC_CONNECTION_REFUSED = 0x80410718, - ERROR_NET_ADHOC_THREAD_ABORTED = 0x80410719, - ERROR_NET_ADHOC_ALREADY_CREATED = 0x8041071A, - ERROR_NET_ADHOC_NOT_IN_GAMEMODE = 0x8041071B, - ERROR_NET_ADHOC_NOT_CREATED = 0x8041071C, - - // pspnet_adhoc_matching - ERROR_NET_ADHOC_MATCHING_INVALID_MODE = 0x80410801, - ERROR_NET_ADHOC_MATCHING_INVALID_PORT = 0x80410802, - ERROR_NET_ADHOC_MATCHING_INVALID_MAXNUM = 0x80410803, - ERROR_NET_ADHOC_MATCHING_RXBUF_TOO_SHORT = 0x80410804, - ERROR_NET_ADHOC_MATCHING_INVALID_OPTLEN = 0x80410805, - ERROR_NET_ADHOC_MATCHING_INVALID_ARG = 0x80410806, - ERROR_NET_ADHOC_MATCHING_INVALID_ID = 0x80410807, - ERROR_NET_ADHOC_MATCHING_ID_NOT_AVAIL = 0x80410808, - ERROR_NET_ADHOC_MATCHING_NO_SPACE = 0x80410809, - ERROR_NET_ADHOC_MATCHING_IS_RUNNING = 0x8041080A, - ERROR_NET_ADHOC_MATCHING_NOT_RUNNING = 0x8041080B, - ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET = 0x8041080C, - ERROR_NET_ADHOC_MATCHING_TARGET_NOT_READY = 0x8041080D, - ERROR_NET_ADHOC_MATCHING_EXCEED_MAXNUM = 0x8041080E, - ERROR_NET_ADHOC_MATCHING_REQUEST_IN_PROGRESS = 0x8041080F, - ERROR_NET_ADHOC_MATCHING_ALREADY_ESTABLISHED = 0x80410810, - ERROR_NET_ADHOC_MATCHING_BUSY = 0x80410811, - ERROR_NET_ADHOC_MATCHING_ALREADY_INITIALIZED = 0x80410812, - ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED = 0x80410813, - ERROR_NET_ADHOC_MATCHING_PORT_IN_USE = 0x80410814, - ERROR_NET_ADHOC_MATCHING_STACKSIZE_TOO_SHORT = 0x80410815, - ERROR_NET_ADHOC_MATCHING_INVALID_DATALEN = 0x80410816, - ERROR_NET_ADHOC_MATCHING_NOT_ESTABLISHED = 0x80410817, - ERROR_NET_ADHOC_MATCHING_DATA_BUSY = 0x80410818, - - // pspnet_adhocctl - ERROR_NET_ADHOCCTL_NOT_LEFT_IBSS = 0x80410b01, - ERROR_NET_ADHOCCTL_ALREADY_CONNECTED = 0x80410b02, - ERROR_NET_ADHOCCTL_WLAN_SWITCH_OFF = 0x80410b03, - ERROR_NET_ADHOCCTL_INVALID_ARG = 0x80410B04, - ERROR_NET_ADHOCCTL_TIMEOUT = 0x80410b05, - ERROR_NET_ADHOCCTL_ID_NOT_FOUND = 0x80410B06, - ERROR_NET_ADHOCCTL_ALREADY_INITIALIZED = 0x80410b07, - ERROR_NET_ADHOCCTL_NOT_INITIALIZED = 0x80410b08, - ERROR_NET_ADHOCCTL_DISCONNECTED = 0x80410b09, - ERROR_NET_ADHOCCTL_NO_SCAN_INFO = 0x80410b0a, - ERROR_NET_ADHOCCTL_INVALID_IBSS = 0x80410b0b, - ERROR_NET_ADHOCCTL_NOT_ENTER_GAMEMODE = 0x80410B0C, - ERROR_NET_ADHOCCTL_CHANNEL_NOT_AVAILABLE = 0x80410B0D, - ERROR_NET_ADHOCCTL_WLAN_BEACON_LOST = 0x80410b0e, - ERROR_NET_ADHOCCTL_WLAN_SUSPENDED = 0x80410b0f, - ERROR_NET_ADHOCCTL_BUSY = 0x80410b10, - ERROR_NET_ADHOCCTL_CHANNEL_NOT_MATCH = 0x80410b11, - ERROR_NET_ADHOCCTL_TOO_MANY_HANDLERS = 0x80410b12, - ERROR_NET_ADHOCCTL_STACKSIZE_TOO_SHORT = 0x80410B13, -}; - const size_t MAX_ADHOCCTL_HANDLERS = 32; //4 const size_t MAX_MATCHING_HANDLERS = 32; //4 diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index 97d55fff8a..5dcd22479a 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -1547,6 +1547,87 @@ const char *KernelErrorToString(u32 err) { case SCE_NET_APCTL_ERROR_INVALID_ID: return "SCE_NET_APCTL_ERROR_INVALID_ID"; case SCE_NET_APCTL_ERROR_WLAN_SUSPENDED: return "SCE_NET_APCTL_ERROR_WLAN_SUSPENDED"; case SCE_NET_APCTL_ERROR_TIMEOUT: return "SCE_NET_APCTL_ERROR_TIMEOUT"; + + // pspnet_adhoc_auth + case SCE_NET_ADHOC_ERROR_AUTH_ALREADY_INITIALIZED: return "SCE_NET_ADHOC_ERROR_AUTH_ALREADY_INITIALIZED"; + + // pspnet_adhoc + case SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID: return "SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID"; + case SCE_NET_ADHOC_ERROR_INVALID_ADDR: return "SCE_NET_ADHOC_ERROR_INVALID_ADDR"; + case SCE_NET_ADHOC_ERROR_INVALID_PORT: return "SCE_NET_ADHOC_ERROR_INVALID_PORT"; + case SCE_NET_ADHOC_ERROR_INVALID_BUFLEN: return "SCE_NET_ADHOC_ERROR_INVALID_BUFLEN"; + case SCE_NET_ADHOC_ERROR_INVALID_DATALEN: return "SCE_NET_ADHOC_ERROR_INVALID_DATALEN"; + case SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE: return "SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE"; + case SCE_NET_ADHOC_ERROR_SOCKET_DELETED: return "SCE_NET_ADHOC_ERROR_SOCKET_DELETED"; + case SCE_NET_ADHOC_ERROR_SOCKET_ALERTED: return "SCE_NET_ADHOC_ERROR_SOCKET_ALERTED"; + case SCE_NET_ADHOC_ERROR_WOULD_BLOCK: return "SCE_NET_ADHOC_ERROR_WOULD_BLOCK"; + case SCE_NET_ADHOC_ERROR_PORT_IN_USE: return "SCE_NET_ADHOC_ERROR_PORT_IN_USE"; + case SCE_NET_ADHOC_ERROR_NOT_CONNECTED: return "SCE_NET_ADHOC_ERROR_NOT_CONNECTED"; + case SCE_NET_ADHOC_ERROR_DISCONNECTED: return "SCE_NET_ADHOC_ERROR_DISCONNECTED"; + case SCE_NET_ADHOC_ERROR_NOT_OPENED: return "SCE_NET_ADHOC_ERROR_NOT_OPENED"; + case SCE_NET_ADHOC_ERROR_NOT_LISTENED: return "SCE_NET_ADHOC_ERROR_NOT_LISTENED"; + case SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL: return "SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL"; + case SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL: return "SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL"; + case SCE_NET_ADHOC_ERROR_INVALID_ARG: return "SCE_NET_ADHOC_ERROR_INVALID_ARG"; + case SCE_NET_ADHOC_ERROR_NOT_INITIALIZED: return "SCE_NET_ADHOC_ERROR_NOT_INITIALIZED"; + case SCE_NET_ADHOC_ERROR_ALREADY_INITIALIZED: return "SCE_NET_ADHOC_ERROR_ALREADY_INITIALIZED"; + case SCE_NET_ADHOC_ERROR_BUSY: return "SCE_NET_ADHOC_ERROR_BUSY"; + case SCE_NET_ADHOC_ERROR_TIMEOUT: return "SCE_NET_ADHOC_ERROR_TIMEOUT"; + case SCE_NET_ADHOC_ERROR_NO_ENTRY: return "SCE_NET_ADHOC_ERROR_NO_ENTRY"; + case SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT: return "SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT"; + case SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED: return "SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED"; + case SCE_NET_ADHOC_ERROR_THREAD_ABORTED: return "SCE_NET_ADHOC_ERROR_THREAD_ABORTED"; + case SCE_NET_ADHOC_ERROR_ALREADY_CREATED: return "SCE_NET_ADHOC_ERROR_ALREADY_CREATED"; + case SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE: return "SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE"; + case SCE_NET_ADHOC_ERROR_NOT_CREATED: return "SCE_NET_ADHOC_ERROR_NOT_CREATED"; + + // pspnet_adhoc_matching + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MODE: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MODE"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_PORT: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_PORT"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MAXNUM: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MAXNUM"; + case SCE_NET_ADHOC_MATCHING_ERROR_RXBUF_TOO_SHORT: return "SCE_NET_ADHOC_MATCHING_ERROR_RXBUF_TOO_SHORT"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID"; + case SCE_NET_ADHOC_MATCHING_ERROR_ID_NOT_AVAIL: return "SCE_NET_ADHOC_MATCHING_ERROR_ID_NOT_AVAIL"; + case SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE: return "SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE"; + case SCE_NET_ADHOC_MATCHING_ERROR_IS_RUNNING: return "SCE_NET_ADHOC_MATCHING_ERROR_IS_RUNNING"; + case SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING: return "SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING"; + case SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET: return "SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET"; + case SCE_NET_ADHOC_MATCHING_ERROR_TARGET_NOT_READY: return "SCE_NET_ADHOC_MATCHING_ERROR_TARGET_NOT_READY"; + case SCE_NET_ADHOC_MATCHING_ERROR_EXCEED_MAXNUM: return "SCE_NET_ADHOC_MATCHING_ERROR_EXCEED_MAXNUM"; + case SCE_NET_ADHOC_MATCHING_ERROR_REQUEST_IN_PROGRESS: return "SCE_NET_ADHOC_MATCHING_ERROR_REQUEST_IN_PROGRESS"; + case SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED: return "SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED"; + case SCE_NET_ADHOC_MATCHING_ERROR_BUSY: return "SCE_NET_ADHOC_MATCHING_ERROR_BUSY"; + case SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_INITIALIZED: return "SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_INITIALIZED"; + case SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED: return "SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED"; + case SCE_NET_ADHOC_MATCHING_ERROR_PORT_IN_USE: return "SCE_NET_ADHOC_MATCHING_ERROR_PORT_IN_USE"; + case SCE_NET_ADHOC_MATCHING_ERROR_STACKSIZE_TOO_SHORT: return "SCE_NET_ADHOC_MATCHING_ERROR_STACKSIZE_TOO_SHORT"; + case SCE_NET_ADHOC_MATCHING_ERROR_INVALID_DATALEN: return "SCE_NET_ADHOC_MATCHING_ERROR_INVALID_DATALEN"; + case SCE_NET_ADHOC_MATCHING_ERROR_NOT_ESTABLISHED: return "SCE_NET_ADHOC_MATCHING_ERROR_NOT_ESTABLISHED"; + case SCE_NET_ADHOC_MATCHING_ERROR_DATA_BUSY: return "SCE_NET_ADHOC_MATCHING_ERROR_DATA_BUSY"; + + // pspnet_adhocctl + case SCE_NET_ADHOCCTL_ERROR_NOT_LEFT_IBSS: return "SCE_NET_ADHOCCTL_ERROR_NOT_LEFT_IBSS"; + case SCE_NET_ADHOCCTL_ERROR_ALREADY_CONNECTED: return "SCE_NET_ADHOCCTL_ERROR_ALREADY_CONNECTED"; + case SCE_NET_ADHOCCTL_ERROR_WLAN_SWITCH_OFF: return "SCE_NET_ADHOCCTL_ERROR_WLAN_SWITCH_OFF"; + case SCE_NET_ADHOCCTL_ERROR_INVALID_ARG: return "SCE_NET_ADHOCCTL_ERROR_INVALID_ARG"; + case SCE_NET_ADHOCCTL_ERROR_TIMEOUT: return "SCE_NET_ADHOCCTL_ERROR_TIMEOUT"; + case SCE_NET_ADHOCCTL_ERROR_ID_NOT_FOUND: return "SCE_NET_ADHOCCTL_ERROR_ID_NOT_FOUND"; + case SCE_NET_ADHOCCTL_ERROR_ALREADY_INITIALIZED: return "SCE_NET_ADHOCCTL_ERROR_ALREADY_INITIALIZED"; + case SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED: return "SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED"; + case SCE_NET_ADHOCCTL_ERROR_DISCONNECTED: return "SCE_NET_ADHOCCTL_ERROR_DISCONNECTED"; + case SCE_NET_ADHOCCTL_ERROR_NO_SCAN_INFO: return "SCE_NET_ADHOCCTL_ERROR_NO_SCAN_INFO"; + case SCE_NET_ADHOCCTL_ERROR_INVALID_IBSS: return "SCE_NET_ADHOCCTL_ERROR_INVALID_IBSS"; + case SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE: return "SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE"; + case SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_AVAILABLE: return "SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_AVAILABLE"; + case SCE_NET_ADHOCCTL_ERROR_WLAN_BEACON_LOST: return "SCE_NET_ADHOCCTL_ERROR_WLAN_BEACON_LOST"; + case SCE_NET_ADHOCCTL_ERROR_WLAN_SUSPENDED: return "SCE_NET_ADHOCCTL_ERROR_WLAN_SUSPENDED"; + case SCE_NET_ADHOCCTL_ERROR_BUSY: return "SCE_NET_ADHOCCTL_ERROR_BUSY"; + case SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_MATCH: return "SCE_NET_ADHOCCTL_ERROR_CHANNEL_NOT_MATCH"; + case SCE_NET_ADHOCCTL_ERROR_TOO_MANY_HANDLERS: return "SCE_NET_ADHOCCTL_ERROR_TOO_MANY_HANDLERS"; + case SCE_NET_ADHOCCTL_ERROR_STACKSIZE_TOO_SHORT: return "SCE_NET_ADHOCCTL_ERROR_STACKSIZE_TOO_SHORT"; + default: return nullptr; } diff --git a/Core/HLE/sceNet.cpp b/Core/HLE/sceNet.cpp index 892bb576f1..c1e81556eb 100644 --- a/Core/HLE/sceNet.cpp +++ b/Core/HLE/sceNet.cpp @@ -1426,7 +1426,7 @@ static int NetApctl_AddHandler(u32 handlerPtr, u32 handlerArg) { if (!foundHandler && Memory::IsValidAddress(handlerPtr)) { if (apctlHandlers.size() >= MAX_APCTL_HANDLERS) { ERROR_LOG(Log::sceNet, "Failed to Add handler(%x, %x): Too many handlers", handlerPtr, handlerArg); - retval = ERROR_NET_ADHOCCTL_TOO_MANY_HANDLERS; // TODO: What's the proper error code for Apctl's TOO_MANY_HANDLERS? + retval = SCE_NET_ADHOCCTL_ERROR_TOO_MANY_HANDLERS; // TODO: What's the proper error code for Apctl's TOO_MANY_HANDLERS? return retval; } apctlHandlers[retval] = handler; diff --git a/Core/HLE/sceNetAdhoc.cpp b/Core/HLE/sceNetAdhoc.cpp index 8457e0bca0..18f709506b 100644 --- a/Core/HLE/sceNetAdhoc.cpp +++ b/Core/HLE/sceNetAdhoc.cpp @@ -179,7 +179,7 @@ static void __GameModeNotify(u64 userdata, int cyclesLate) { port = it->second; int sent = hleCall(sceNetAdhoc, int, sceNetAdhocPdpSend, gameModeSocket, (const char*)&gma.mac, port, masterGameModeArea.data, masterGameModeArea.size, 0, ADHOC_F_NONBLOCK); - if (sent != ERROR_NET_ADHOC_WOULD_BLOCK) { + if (sent != SCE_NET_ADHOC_ERROR_WOULD_BLOCK) { gma.dataSent = 1; DEBUG_LOG(Log::sceNet, "GameMode: Master data Sent %d bytes to Area #%d [%s]", masterGameModeArea.size, gma.id, mac2str(&gma.mac).c_str()); sentcount++; @@ -298,7 +298,7 @@ static void __AdhocctlNotify(u64 userdata, int cyclesLate) { // Socket not found?! Should never happen! But if it ever happened (ie. loaded from SaveState where adhocctlRequests got cleared) return BUSY and let the game try again. if (adhocctlRequests.find(uid) == adhocctlRequests.end()) { WARN_LOG(Log::sceNet, "sceNetAdhocctl Socket WaitID(%i) not found!", uid); - __KernelResumeThreadFromWait(threadID, ERROR_NET_ADHOCCTL_BUSY); + __KernelResumeThreadFromWait(threadID, SCE_NET_ADHOCCTL_ERROR_BUSY); return; } @@ -352,11 +352,11 @@ static void __AdhocctlNotify(u64 userdata, int cyclesLate) { return; } else if (req.opcode != OPCODE_LOGIN) - result = ERROR_NET_ADHOCCTL_BUSY; + result = SCE_NET_ADHOCCTL_ERROR_BUSY; } } else - result = ERROR_NET_ADHOCCTL_WLAN_SWITCH_OFF; + result = SCE_NET_ADHOCCTL_ERROR_WLAN_SWITCH_OFF; u32 waitVal = __KernelGetWaitValue(threadID, error); __KernelResumeThreadFromWait(threadID, result); @@ -401,7 +401,7 @@ int WaitBlockingAdhocctlSocket(AdhocctlRequest request, int usec, const char* re if (adhocctlRequests.find(uid) != adhocctlRequests.end()) { WARN_LOG(Log::sceNet, "sceNetAdhocctl - WaitID[%d] already existed, Socket is busy!", uid); - return ERROR_NET_ADHOCCTL_BUSY; + return SCE_NET_ADHOCCTL_ERROR_BUSY; } u64 param = ((u64)__KernelGetCurThread()) << 32 | uid; @@ -439,12 +439,12 @@ int StartGameModeScheduler() { int DoBlockingPdpRecv(AdhocSocketRequest& req, s64& result) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& pdpsocket = sock->data.pdp; if (sock->flags & ADHOC_F_ALERTRECV) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTRECV; return 0; } @@ -475,7 +475,7 @@ int DoBlockingPdpRecv(AdhocSocketRequest& req, s64& result) { // Try again later, until timeout reached u64 now = (u64)(time_now_d() * 1000000.0); if (req.timeout != 0 && now - req.startTime > req.timeout) { - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; DEBUG_LOG(Log::sceNet, "sceNetAdhocPdpRecv[%i]: Discard Timeout", req.id); return 0; } @@ -530,7 +530,7 @@ int DoBlockingPdpRecv(AdhocSocketRequest& req, s64& result) { return -1; } else - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } // Returning required buffer size when available data in recv buffer is larger than provided buffer size else if (ret > *req.length) { @@ -549,11 +549,11 @@ int DoBlockingPdpRecv(AdhocSocketRequest& req, s64& result) { if (peer != NULL) peer->last_recv = CoreTiming::GetGlobalTimeUsScaled(); peerlock.unlock(); } - result = ERROR_NET_ADHOC_NOT_ENOUGH_SPACE; + result = SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE; } // FIXME: Blocking operation with infinite timeout(0) should never get a TIMEOUT error, right? May be we should return INVALID_ARG instead if it was infinite timeout (0)? else - result = ERROR_NET_ADHOC_TIMEOUT; // ERROR_NET_ADHOC_INVALID_ARG; // ERROR_NET_ADHOC_DISCONNECTED + result = SCE_NET_ADHOC_ERROR_TIMEOUT; // SCE_NET_ADHOC_ERROR_INVALID_ARG; // SCE_NET_ADHOC_ERROR_DISCONNECTED if (ret == SOCKET_ERROR) DEBUG_LOG(Log::sceNet, "sceNetAdhocPdpRecv[%i]: Socket Error (%i)", req.id, sockerr); @@ -564,12 +564,12 @@ int DoBlockingPdpRecv(AdhocSocketRequest& req, s64& result) { int DoBlockingPdpSend(AdhocSocketRequest& req, s64& result, AdhocSendTargets& targetPeers) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& pdpsocket = sock->data.pdp; if (sock->flags & ADHOC_F_ALERTSEND) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTSEND; return 0; } @@ -599,7 +599,7 @@ int DoBlockingPdpSend(AdhocSocketRequest& req, s64& result, AdhocSendTargets& ta } else // FIXME: Does Broadcast always success? even with timeout/blocking? - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } ++peer; } @@ -617,12 +617,12 @@ int DoBlockingPdpSend(AdhocSocketRequest& req, s64& result, AdhocSendTargets& ta int DoBlockingPtpSend(AdhocSocketRequest& req, s64& result) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& ptpsocket = sock->data.ptp; if (sock->flags & ADHOC_F_ALERTSEND) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTSEND; return 0; } @@ -651,14 +651,14 @@ int DoBlockingPtpSend(AdhocSocketRequest& req, s64& result) { return -1; } else - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } else { // Change Socket State. // FIXME: Does Alerted Socket should be closed too? ptpsocket.state = ADHOC_PTP_STATE_CLOSED; // Disconnected - result = ERROR_NET_ADHOC_DISCONNECTED; + result = SCE_NET_ADHOC_ERROR_DISCONNECTED; } if (ret == SOCKET_ERROR) @@ -670,12 +670,12 @@ int DoBlockingPtpSend(AdhocSocketRequest& req, s64& result) { int DoBlockingPtpRecv(AdhocSocketRequest& req, s64& result) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& ptpsocket = sock->data.ptp; if (sock->flags & ADHOC_F_ALERTRECV) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTRECV; return 0; } @@ -707,14 +707,14 @@ int DoBlockingPtpRecv(AdhocSocketRequest& req, s64& result) { return -1; } else - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } else { // Change Socket State. // FIXME: Does Alerted Socket should be closed too? ptpsocket.state = ADHOC_PTP_STATE_CLOSED; // Disconnected - result = ERROR_NET_ADHOC_DISCONNECTED; // ERROR_NET_ADHOC_INVALID_ARG + result = SCE_NET_ADHOC_ERROR_DISCONNECTED; // SCE_NET_ADHOC_ERROR_INVALID_ARG } if (ret == SOCKET_ERROR) @@ -726,12 +726,12 @@ int DoBlockingPtpRecv(AdhocSocketRequest& req, s64& result) { int DoBlockingPtpAccept(AdhocSocketRequest& req, s64& result) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& ptpsocket = sock->data.ptp; if (sock->flags & ADHOC_F_ALERTACCEPT) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTACCEPT; return 0; } @@ -761,11 +761,11 @@ int DoBlockingPtpAccept(AdhocSocketRequest& req, s64& result) { return -1; } else { - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } } else - result = ERROR_NET_ADHOC_INVALID_ARG; //ERROR_NET_ADHOC_TIMEOUT + result = SCE_NET_ADHOC_ERROR_INVALID_ARG; //SCE_NET_ADHOC_ERROR_TIMEOUT if (ret == SOCKET_ERROR) DEBUG_LOG(Log::sceNet, "sceNetAdhocPtpAccept[%i]: Socket Error (%i)", req.id, sockerr); @@ -776,12 +776,12 @@ int DoBlockingPtpAccept(AdhocSocketRequest& req, s64& result) { int DoBlockingPtpConnect(AdhocSocketRequest& req, s64& result, AdhocSendTargets& targetPeer) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& ptpsocket = sock->data.ptp; if (sock->flags & ADHOC_F_ALERTCONNECT) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTCONNECT; return 0; } @@ -866,9 +866,9 @@ int DoBlockingPtpConnect(AdhocSocketRequest& req, s64& result, AdhocSendTargets& else { // Handle Workaround that force the first Connect to be blocking for issue related to lobby or high latency networks if (sock->nonblocking) - result = ERROR_NET_ADHOC_WOULD_BLOCK; + result = SCE_NET_ADHOC_ERROR_WOULD_BLOCK; else - result = ERROR_NET_ADHOC_TIMEOUT; // FIXME: PSP never returned ERROR_NET_ADHOC_TIMEOUT on PtpConnect? or only returned ERROR_NET_ADHOC_TIMEOUT when the host is too busy? Seems to be returning ERROR_NET_ADHOC_CONNECTION_REFUSED on timedout instead (if the other side in not listening yet, which is similar to BSD). + result = SCE_NET_ADHOC_ERROR_TIMEOUT; // FIXME: PSP never returned SCE_NET_ADHOC_ERROR_TIMEOUT on PtpConnect? or only returned SCE_NET_ADHOC_ERROR_TIMEOUT when the host is too busy? Seems to be returning SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED on timedout instead (if the other side in not listening yet, which is similar to BSD). // Done return 0; @@ -884,12 +884,12 @@ int DoBlockingPtpConnect(AdhocSocketRequest& req, s64& result, AdhocSendTargets& int DoBlockingPtpFlush(AdhocSocketRequest& req, s64& result) { auto sock = adhocSockets[req.id - 1]; if (!sock) { - result = ERROR_NET_ADHOC_SOCKET_DELETED; + result = SCE_NET_ADHOC_ERROR_SOCKET_DELETED; return 0; } auto& ptpsocket = sock->data.ptp; if (sock->flags & ADHOC_F_ALERTFLUSH) { - result = ERROR_NET_ADHOC_SOCKET_ALERTED; + result = SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; sock->alerted_flags |= ADHOC_F_ALERTFLUSH; return 0; } @@ -904,7 +904,7 @@ int DoBlockingPtpFlush(AdhocSocketRequest& req, s64& result) { return -1; } else - result = ERROR_NET_ADHOC_TIMEOUT; + result = SCE_NET_ADHOC_ERROR_TIMEOUT; } if (sockerr != 0) { @@ -924,10 +924,10 @@ int DoBlockingAdhocPollSocket(AdhocSocketRequest& req, s64& result) { return -1; } else if (ret < 0) - ret = ERROR_NET_ADHOC_EXCEPTION_EVENT; - // FIXME: Does AdhocPollSocket can return any error code other than ERROR_NET_ADHOC_EXCEPTION_EVENT? + ret = SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT; + // FIXME: Does AdhocPollSocket can return any error code other than SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT? //else - // ret = ERROR_NET_ADHOC_TIMEOUT; + // ret = SCE_NET_ADHOC_ERROR_TIMEOUT; } result = ret; @@ -963,7 +963,7 @@ static void __AdhocSocketNotify(u64 userdata, int cyclesLate) { // Socket not found?! Should never happened! But if it ever happened (ie. loaded from SaveState where adhocSocketRequests got cleared) return TIMEOUT and let the game try again. if (adhocSocketRequests.find(userdata) == adhocSocketRequests.end()) { WARN_LOG(Log::sceNet, "sceNetAdhoc Socket WaitID(%i) on Thread(%i) not found!", uid, threadID); - __KernelResumeThreadFromWait(threadID, ERROR_NET_ADHOC_TIMEOUT); + __KernelResumeThreadFromWait(threadID, SCE_NET_ADHOC_ERROR_TIMEOUT); return; } @@ -1054,7 +1054,7 @@ int WaitBlockingAdhocSocket(u64 threadSocketId, int type, int pspSocketId, void* if (adhocSocketRequests.find(threadSocketId) != adhocSocketRequests.end()) { WARN_LOG(Log::sceNet, "sceNetAdhoc[%d] - ThreadID[%d] WaitID[%d] already existed, Socket[%d] is busy!", type, static_cast(threadSocketId >> 32), uid, pspSocketId); // FIXME: Not sure if Adhoc Socket can return ADHOC_BUSY or not (assuming it's similar to EINPROGRESS for Adhoc Socket), or may be we should return TIMEOUT instead? - return ERROR_NET_ADHOC_BUSY; // ERROR_NET_ADHOC_TIMEOUT + return SCE_NET_ADHOC_ERROR_BUSY; // SCE_NET_ADHOC_ERROR_TIMEOUT } //changeBlockingMode(socketId, 1); @@ -1070,7 +1070,7 @@ int WaitBlockingAdhocSocket(u64 threadSocketId, int type, int pspSocketId, void* __KernelWaitCurThread(WAITTYPE_NET, uid, 0, 0, false, reason); // Fallback return value - return ERROR_NET_ADHOC_TIMEOUT; + return SCE_NET_ADHOC_ERROR_TIMEOUT; } void __NetAdhocDoState(PointerWrap &p) { @@ -1220,17 +1220,17 @@ u32 sceNetAdhocInit() { return hleLogInfo(Log::sceNet, 0, "at %08x", currentMIPS->pc); } // Already initialized - return hleLogWarning(Log::sceNet, ERROR_NET_ADHOC_ALREADY_INITIALIZED, "already initialized"); + return hleLogWarning(Log::sceNet, SCE_NET_ADHOC_ERROR_ALREADY_INITIALIZED, "already initialized"); } int sceNetAdhocctlInit(int stackSize, int prio, u32 productAddr) { INFO_LOG(Log::sceNet, "sceNetAdhocctlInit(%i, %i, %08x) at %08x", stackSize, prio, productAddr, currentMIPS->pc); // FIXME: Returning 0x8002013a (SCE_KERNEL_ERROR_LIBRARY_NOT_YET_LINKED) without adhoc module loaded first? - // FIXME: Sometimes returning 0x80410601 (ERROR_NET_ADHOC_AUTH_ALREADY_INITIALIZED / Library module is already initialized ?) when AdhocctlTerm is not fully done? + // FIXME: Sometimes returning 0x80410601 (SCE_NET_ADHOC_ERROR_AUTH_ALREADY_INITIALIZED / Library module is already initialized ?) when AdhocctlTerm is not fully done? if (netAdhocctlInited) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_ALREADY_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_ALREADY_INITIALIZED); } auto product = PSPPointer::Create(productAddr); @@ -1275,11 +1275,11 @@ int NetAdhocctl_GetState() { int sceNetAdhocctlGetState(u32 ptrToStatus) { // Library uninitialized if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED); // Invalid Arguments if (!Memory::IsValidAddress(ptrToStatus)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG); int state = NetAdhocctl_GetState(); // Output Adhocctl State @@ -1316,7 +1316,7 @@ int sceNetAdhocPdpCreate(const char *mac, int port, int bufferSize, u32 flag) { // Port is in use by another PDP Socket. if (isPDPPortInUse(port)) { // FIXME: When PORT_IN_USE error occured it seems the index to the socket id also increased, which means it tries to create & bind the socket first and then closes it due to failed to bind - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_IN_USE, "port in use"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_IN_USE, "port in use"); } //sport 0 should be shifted back to 0 when using offset Phantasy Star Portable 2 use this @@ -1439,7 +1439,7 @@ int sceNetAdhocPdpCreate(const char *mac, int port, int bufferSize, u32 flag) { auto n = GetI18NCategory(I18NCat::NETWORKING); g_OSD.Show(OSDType::MESSAGE_ERROR, std::string(n->T("Failed to Bind Port")) + " " + std::to_string(port + portOffset) + "\n" + std::string(n->T("Please change your Port Offset")), 0.0f, "portbindfail"); - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_NOT_AVAIL, "port not available"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL, "port not available"); } } @@ -1448,14 +1448,14 @@ int sceNetAdhocPdpCreate(const char *mac, int port, int bufferSize, u32 flag) { } // Invalid MAC supplied - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ADDR, "invalid address"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ADDR, "invalid address"); } // Invalid Arguments were supplied - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Library is uninitialized - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "adhoc not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "adhoc not initialized"); } /** @@ -1469,17 +1469,17 @@ static int sceNetAdhocctlGetParameter(u32 paramAddr) { parameter.nickname.data[ADHOCCTL_NICKNAME_LEN - 1] = 0; DEBUG_LOG(Log::sceNet, "sceNetAdhocctlGetParameter(%08x) [Ch=%i][Group=%s][BSSID=%s][name=%s]", paramAddr, parameter.channel, grpName, mac2str(¶meter.bssid.mac_addr).c_str(), parameter.nickname.data); if (!g_Config.bEnableWlan) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_DISCONNECTED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_DISCONNECTED); } // Library initialized if (!netAdhocctlInited) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED); } auto ptr = PSPPointer::Create(paramAddr); if (!ptr.IsValid()) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG); *ptr = parameter; ptr.NotifyWrite("NetAdhocctlGetParameter"); @@ -1541,7 +1541,7 @@ int sceNetAdhocPdpSend(int id, const char *mac, u32 port, void *data, int len, i if (socket->flags & ADHOC_F_ALERTSEND) { socket->alerted_flags |= ADHOC_F_ALERTSEND; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Single Target @@ -1570,7 +1570,7 @@ int sceNetAdhocPdpSend(int id, const char *mac, u32 port, void *data, int len, i u64 threadSocketId = ((u64)__KernelGetCurThread()) << 32 | pdpsocket.id; if (sendTargetPeers.find(threadSocketId) != sendTargetPeers.end()) { DEBUG_LOG(Log::sceNet, "sceNetAdhocPdpSend[%i:%u]: Socket(%d) is Busy!", id, getLocalPort(pdpsocket.id), pdpsocket.id); - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_BUSY, "busy?"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_BUSY, "busy?"); } AdhocSendTargets dest = { len, {}, false }; @@ -1597,10 +1597,10 @@ int sceNetAdhocPdpSend(int id, const char *mac, u32 port, void *data, int len, i // Non-Blocking if (flag) - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); // Does PDP can Timeout? There is no concept of Timeout when sending UDP due to no ACK, but might happen if the socket buffer is full, not sure about PDP since some games did use the timeout arg - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_TIMEOUT, "timeout?"); // ERROR_NET_ADHOC_INVALID_ADDR; + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_TIMEOUT, "timeout?"); // SCE_NET_ADHOC_ERROR_INVALID_ADDR; } VERBOSE_LOG(Log::sceNet, "sceNetAdhocPdpSend[%i:%u]: Unknown Target Peer %s:%u (faking success)\n", id, getLocalPort(pdpsocket.id), mac2str(daddr).c_str(), ntohs(target.sin_port)); return 0; // faking success @@ -1646,7 +1646,7 @@ int sceNetAdhocPdpSend(int id, const char *mac, u32 port, void *data, int len, i u64 threadSocketId = ((u64)__KernelGetCurThread()) << 32 | pdpsocket.id; if (sendTargetPeers.find(threadSocketId) != sendTargetPeers.end()) { DEBUG_LOG(Log::sceNet, "sceNetAdhocPdpSend[%i:%u](BC): Socket(%d) is Busy!", id, getLocalPort(pdpsocket.id), pdpsocket.id); - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_BUSY, "busy?"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_BUSY, "busy?"); } sendTargetPeers[threadSocketId] = dest; @@ -1686,27 +1686,27 @@ int sceNetAdhocPdpSend(int id, const char *mac, u32 port, void *data, int len, i } // Invalid Destination Address - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_ADDR, "invalid address"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ADDR, "invalid address"); } // Invalid Argument - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Invalid Socket ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Invalid Data Length - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_DATALEN, "invalid data length"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_DATALEN, "invalid data length"); } // Invalid Destination Port - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_PORT, "invalid port"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_PORT, "invalid port"); } // Library is uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } /** @@ -1774,7 +1774,7 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen if (socket->flags & ADHOC_F_ALERTRECV) { socket->alerted_flags |= ADHOC_F_ALERTRECV; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Sender Address @@ -1792,7 +1792,7 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen while (--disCnt > 0) { // Receive Data. PDP always sent in full size or nothing(failed), recvfrom will always receive in full size as requested (blocking) or failed (non-blocking). If available UDP data is larger than buffer, excess data is lost. - // Should peek first for the available data size if it's more than len return ERROR_NET_ADHOC_NOT_ENOUGH_SPACE along with required size in len to prevent losing excess data + // Should peek first for the available data size if it's more than len return SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE along with required size in len to prevent losing excess data // On Windows: MSG_TRUNC are not supported on recvfrom (socket error WSAEOPNOTSUPP), so we use dummy buffer as an alternative sinlen = sizeof(sin); memset(&sin, 0, sinlen); @@ -1810,8 +1810,8 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen memset(&sin, 0, sinlen); recvfrom(pdpsocket.id, dummyPeekBuf64k, dummyPeekBuf64kSize, MSG_NOSIGNAL, (struct sockaddr*)&sin, &sinlen); if (flag) { - VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block (disc)", ERROR_NET_ADHOC_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) - return ERROR_NET_ADHOC_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block (disc)"); + VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block (disc)", SCE_NET_ADHOC_ERROR_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) + return SCE_NET_ADHOC_ERROR_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block (disc)"); } else { // Simulate blocking behaviour with non-blocking socket, and discard more unresolvable packets until timeout reached @@ -1843,7 +1843,7 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen if (peer != NULL) peer->last_recv = CoreTiming::GetGlobalTimeUsScaled(); peerlock.unlock(); - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_NOT_ENOUGH_SPACE, "not enough space"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_ENOUGH_SPACE, "not enough space"); } sinlen = sizeof(sin); @@ -1860,8 +1860,8 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen return WaitBlockingAdhocSocket(threadSocketId, PDP_RECV, id, buf, len, timeout, saddr, sport, "pdp recv"); } - VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block", ERROR_NET_ADHOC_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) - return ERROR_NET_ADHOC_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block", SCE_NET_ADHOC_ERROR_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) + return SCE_NET_ADHOC_ERROR_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); } hleEatMicro(50); @@ -1899,8 +1899,8 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen // Receiving data from unknown peer? Should never reached here! Unless the Peeked's packet was different than the Recved one (which mean there is a problem) WARN_LOG(Log::sceNet, "sceNetAdhocPdpRecv[%i:%u]: Received %i bytes from Unknown Peer %s:%u", id, getLocalPort(pdpsocket.id), received, ip2str(sin.sin_addr).c_str(), ntohs(sin.sin_port)); if (flag) { - VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block (problem)", ERROR_NET_ADHOC_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) - return ERROR_NET_ADHOC_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block (problem)"); + VERBOSE_LOG(Log::sceNet, "%08x=sceNetAdhocPdpRecv: would block (problem)", SCE_NET_ADHOC_ERROR_WOULD_BLOCK); // Temporary fix to avoid a crash on the Logs due to trying to Logs syscall's argument from another thread (ie. AdhocMatchingInput thread) + return SCE_NET_ADHOC_ERROR_WOULD_BLOCK; // hleLogSuccessVerboseX(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block (problem)"); } } @@ -1915,24 +1915,24 @@ int sceNetAdhocPdpRecv(int id, void *addr, void * port, void *buf, void *dataLen DEBUG_LOG(Log::sceNet, "sceNetAdhocPdpRecv[%i:%u]: Result:%i (Error:%i)", id, pdpsocket.lport, received, error); // Unexpected error (other than EAGAIN/EWOULDBLOCK/ECONNRESET) or in case the Peeked's packet was different than Recved one, treated as Timeout? - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_TIMEOUT, "timeout?"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_TIMEOUT, "timeout?"); } // Invalid Argument - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Invalid Socket ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Library is uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } int NetAdhoc_SetSocketAlert(int id, s32_le flag) { if (id < 1 || id > MAX_SOCKET || adhocSockets[id - 1] == NULL) - return ERROR_NET_ADHOC_INVALID_SOCKET_ID; + return SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID; // FIXME: Should we check for valid Alert Flags and/or Mask them? Should we return an error if we found an invalid flag? s32_le flg = flag & ADHOC_F_ALERTALL; @@ -1964,7 +1964,7 @@ int PollAdhocSocket(SceNetAdhocPollSd* sds, int count, int timeout, int nonblock if (sds[i].id > 0 && sds[i].id <= MAX_SOCKET && adhocSockets[sds[i].id - 1] != NULL) { auto sock = adhocSockets[sds[i].id - 1]; if (!sock) { - return ERROR_NET_ADHOC_SOCKET_DELETED; + return SCE_NET_ADHOC_ERROR_SOCKET_DELETED; } if (sock->type == SOCK_PTP) { fd = sock->data.ptp.id; @@ -2025,7 +2025,7 @@ int PollAdhocSocket(SceNetAdhocPollSd* sds, int count, int timeout, int nonblock if (sock->flags & ADHOC_F_ALERTPOLL) { sock->alerted_flags |= ADHOC_F_ALERTPOLL; - return ERROR_NET_ADHOC_SOCKET_ALERTED; + return SCE_NET_ADHOC_ERROR_SOCKET_ALERTED; } } else { @@ -2035,13 +2035,13 @@ int PollAdhocSocket(SceNetAdhocPollSd* sds, int count, int timeout, int nonblock } } else { - // FIXME: Does AdhocPollSocket can return any error code other than ERROR_NET_ADHOC_EXCEPTION_EVENT on blocking/non-blocking mode? + // FIXME: Does AdhocPollSocket can return any error code other than SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT on blocking/non-blocking mode? /*if (nonblock) - affectedsockets = ERROR_NET_ADHOC_WOULD_BLOCK; + affectedsockets = SCE_NET_ADHOC_ERROR_WOULD_BLOCK; else - affectedsockets = ERROR_NET_ADHOC_TIMEOUT; + affectedsockets = SCE_NET_ADHOC_ERROR_TIMEOUT; */ - affectedsockets = ERROR_NET_ADHOC_EXCEPTION_EVENT; + affectedsockets = SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT; } return affectedsockets; } @@ -2061,7 +2061,7 @@ int sceNetAdhocPollSocket(u32 socketStructAddr, int count, int timeout, int nonb for (int i = 0; i < count; i++) { // Invalid Socket if (sds[i].id < 1 || sds[i].id > MAX_SOCKET || adhocSockets[sds[i].id - 1] == NULL) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Nonblocking Mode @@ -2069,7 +2069,7 @@ int sceNetAdhocPollSocket(u32 socketStructAddr, int count, int timeout, int nonb timeout = 0; if (count > (int)FD_SETSIZE) - count = FD_SETSIZE; // return 0; //ERROR_NET_ADHOC_INVALID_ARG + count = FD_SETSIZE; // return 0; //SCE_NET_ADHOC_ERROR_INVALID_ARG // Acquire Network Lock //acquireNetworkLock(); @@ -2091,7 +2091,7 @@ int sceNetAdhocPollSocket(u32 socketStructAddr, int count, int timeout, int nonb // No Events generated // Non-blocking mode - // Bleach 7 seems to use nonblocking and check the return value > 0, or 0x80410709 (ERROR_NET_ADHOC_WOULD_BLOCK), also 0x80410717 (ERROR_NET_ADHOC_EXCEPTION_EVENT), when using prx files on JPCSP it can return 0 + // Bleach 7 seems to use nonblocking and check the return value > 0, or 0x80410709 (SCE_NET_ADHOC_ERROR_WOULD_BLOCK), also 0x80410717 (SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT), when using prx files on JPCSP it can return 0 if (affectedsockets >= 0) { if (affectedsockets > 0) { for (int i = 0; i < count; i++) { @@ -2109,17 +2109,17 @@ int sceNetAdhocPollSocket(u32 socketStructAddr, int count, int timeout, int nonb return hleLogDebug(Log::sceNet, affectedsockets, "success"); } //else if (nonblock && affectedsockets < 0) - // return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); // Is this error code valid for PollSocket? as it always returns 0 even when nonblock flag is set + // return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); // Is this error code valid for PollSocket? as it always returns 0 even when nonblock flag is set - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_EXCEPTION_EVENT, "exception event"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_EXCEPTION_EVENT, "exception event"); } // Invalid Argument - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Library is uninitialized - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "adhoc not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "adhoc not initialized"); } int NetAdhocPdp_Delete(int id, int unknown) { @@ -2151,15 +2151,15 @@ int NetAdhocPdp_Delete(int id, int unknown) { } // Invalid Socket ID - return ERROR_NET_ADHOC_INVALID_SOCKET_ID; + return SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID; } // Invalid Argument - return ERROR_NET_ADHOC_INVALID_ARG; + return SCE_NET_ADHOC_ERROR_INVALID_ARG; } // Library is uninitialized - return ERROR_NET_ADHOC_NOT_INITIALIZED; + return SCE_NET_ADHOC_ERROR_NOT_INITIALIZED; } /** @@ -2184,11 +2184,11 @@ static int sceNetAdhocctlGetAdhocId(u32 productStructAddr) { INFO_LOG(Log::sceNet, "sceNetAdhocctlGetAdhocId(%08x) at %08x", productStructAddr, currentMIPS->pc); if (!netAdhocctlInited) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); auto productStruct = PSPPointer::Create(productStructAddr); if (!productStruct.IsValid()) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); *productStruct = product_code; productStruct.NotifyWrite("NetAdhocctlGetAdhocId"); @@ -2209,7 +2209,7 @@ int sceNetAdhocctlScan() { // FIXME: When tested with JPCSP + official prx files it seems when adhocctl in a connected state (ie. joined to a group) attempting to create/connect/join/scan will return a success (without doing anything?) if ((adhocctlState == ADHOCCTL_STATE_CONNECTED) || (adhocctlState == ADHOCCTL_STATE_GAMEMODE)) { // TODO: Valhalla Knights 2 need handler notification, but need to test this on games that doesn't use Adhocctl Handler too (not sure if there are games like that tho) - notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, ERROR_NET_ADHOCCTL_ALREADY_CONNECTED); + notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, SCE_NET_ADHOCCTL_ERROR_ALREADY_CONNECTED); hleEatMicro(500); return hleLogDebug(Log::sceNet, 0); } @@ -2243,11 +2243,11 @@ int sceNetAdhocctlScan() { } // FIXME: Returning BUSY when previous adhocctl handler's callback is not fully executed yet, But returning success and notifying handler's callback with error (ie. ALREADY_CONNECTED) when previous adhocctl handler's callback is fully executed? Is there a case where error = BUSY sent through handler's callback? - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_BUSY, "busy"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_BUSY, "busy"); } // Library uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); } int sceNetAdhocctlGetScanInfo(u32 sizeAddr, u32 bufAddr) { @@ -2264,7 +2264,7 @@ int sceNetAdhocctlGetScanInfo(u32 sizeAddr, u32 bufAddr) { // Library initialized if (netAdhocctlInited) { // Minimum Argument - if (buflen == NULL) return ERROR_NET_ADHOCCTL_INVALID_ARG; + if (buflen == NULL) return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; // Minimum Argument Requirements if (buflen != NULL) { @@ -2347,7 +2347,7 @@ int sceNetAdhocctlGetScanInfo(u32 sizeAddr, u32 bufAddr) { } // Library uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED); } // TODO: How many handlers can the PSP actually have for Adhocctl? @@ -2375,7 +2375,7 @@ static u32 sceNetAdhocctlAddHandler(u32 handlerPtr, u32 handlerArg) { if (!foundHandler && Memory::IsValidAddress(handlerPtr)) { if (adhocctlHandlers.size() >= MAX_ADHOCCTL_HANDLERS) { ERROR_LOG(Log::sceNet, "UNTESTED sceNetAdhocctlAddHandler(%x, %x): Too many handlers", handlerPtr, handlerArg); - retval = ERROR_NET_ADHOCCTL_TOO_MANY_HANDLERS; + retval = SCE_NET_ADHOCCTL_ERROR_TOO_MANY_HANDLERS; return retval; } adhocctlHandlers[retval] = handler; @@ -2385,7 +2385,7 @@ static u32 sceNetAdhocctlAddHandler(u32 handlerPtr, u32 handlerArg) { retval = 0; //Faking success } else { ERROR_LOG(Log::sceNet, "UNTESTED sceNetAdhocctlAddHandler(%x, %x): Invalid handler", handlerPtr, handlerArg); - retval = ERROR_NET_ADHOCCTL_INVALID_ARG; + retval = SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; } // The id to return is the number of handlers currently registered @@ -2400,7 +2400,7 @@ u32 NetAdhocctl_Disconnect() { hleEatMicro(16667); if (isAdhocctlBusy && CoreTiming::IsScheduled(adhocctlNotifyEvent)) { - return ERROR_NET_ADHOCCTL_BUSY; + return SCE_NET_ADHOCCTL_ERROR_BUSY; } // Connected State (Adhoc Mode). Attempting to leave a group while not in a group will be kicked out by Adhoc Server (ie. some games tries to disconnect more than once within a short time) @@ -2436,7 +2436,7 @@ u32 NetAdhocctl_Disconnect() { } else { // Set Disconnected State - return ERROR_NET_ADHOCCTL_BUSY; + return SCE_NET_ADHOCCTL_ERROR_BUSY; } } @@ -2474,7 +2474,7 @@ u32 NetAdhocctl_Disconnect() { } // Library uninitialized - return ERROR_NET_ADHOCCTL_NOT_INITIALIZED; + return SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED; } int sceNetAdhocctlDisconnect() { @@ -2487,7 +2487,7 @@ int sceNetAdhocctlDisconnect() { static u32 sceNetAdhocctlDelHandler(u32 handlerID) { if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "adhocctl not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "adhocctl not initialized"); if (adhocctlHandlers.find(handlerID) != adhocctlHandlers.end()) { adhocctlHandlers.erase(handlerID); @@ -2612,15 +2612,15 @@ static int sceNetAdhocctlGetNameByAddr(const char *mac, u32 nameAddr) { peerlock.unlock(); // Player not found - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NO_ENTRY, "PlayerName not found"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NO_ENTRY, "PlayerName not found"); } // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG); } // Library uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED); } int sceNetAdhocctlGetPeerInfo(const char *mac, int size, u32 peerInfoAddr) { @@ -2636,9 +2636,9 @@ int sceNetAdhocctlGetPeerInfo(const char *mac, int size, u32 peerInfoAddr) { } // Library initialized if (netAdhocctlInited) { - if ((size < (int)sizeof(SceNetAdhocctlPeerInfoEmu)) || (buf == NULL)) return ERROR_NET_ADHOCCTL_INVALID_ARG; + if ((size < (int)sizeof(SceNetAdhocctlPeerInfoEmu)) || (buf == NULL)) return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; - int retval = ERROR_NET_ADHOC_NO_ENTRY; // -1; + int retval = SCE_NET_ADHOC_ERROR_NO_ENTRY; // -1; // Local MAC if (isLocalMAC(maddr)) { @@ -2687,7 +2687,7 @@ int sceNetAdhocctlGetPeerInfo(const char *mac, int size, u32 peerInfoAddr) { } // Library uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED); } int NetAdhocctl_Create(const char *groupName) { @@ -2698,7 +2698,7 @@ int NetAdhocctl_Create(const char *groupName) { // FIXME: When tested with JPCSP + official prx files it seems when adhocctl in a connected state (ie. joined to a group) attempting to create/connect/join/scan will return a success (without doing anything?) if ((adhocctlState == ADHOCCTL_STATE_CONNECTED) || (adhocctlState == ADHOCCTL_STATE_GAMEMODE)) { // TODO: Need to test this on games that doesn't use Adhocctl Handler too (not sure if there are games like that tho) - notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, ERROR_NET_ADHOCCTL_ALREADY_CONNECTED); + notifyAdhocctlHandlers(ADHOCCTL_EVENT_ERROR, SCE_NET_ADHOCCTL_ERROR_ALREADY_CONNECTED); hleEatMicro(500); return 0; } @@ -2746,14 +2746,14 @@ int NetAdhocctl_Create(const char *groupName) { } // Connected State - return ERROR_NET_ADHOCCTL_BUSY; // ERROR_NET_ADHOCCTL_BUSY may trigger the game (ie. Ford Street Racing) to call sceNetAdhocctlDisconnect + return SCE_NET_ADHOCCTL_ERROR_BUSY; // SCE_NET_ADHOCCTL_ERROR_BUSY may trigger the game (ie. Ford Street Racing) to call sceNetAdhocctlDisconnect } // Invalid Argument - return ERROR_NET_ADHOC_INVALID_ARG; + return SCE_NET_ADHOC_ERROR_INVALID_ARG; } // Library uninitialized - return ERROR_NET_ADHOCCTL_NOT_INITIALIZED; + return SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED; } /** @@ -2814,22 +2814,22 @@ int sceNetAdhocctlJoin(u32 scanInfoAddr) { } // Invalid Argument - return ERROR_NET_ADHOCCTL_INVALID_ARG; + return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; } // Uninitialized Library - return ERROR_NET_ADHOCCTL_NOT_INITIALIZED; + return SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED; } int NetAdhocctl_CreateEnterGameMode(const char* group_name, int game_type, int num_members, u32 membersAddr, u32 timeout, int flag) { if (!netAdhocctlInited) - return ERROR_NET_ADHOCCTL_NOT_INITIALIZED; + return SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED; if (!Memory::IsValidAddress(membersAddr)) - return ERROR_NET_ADHOCCTL_INVALID_ARG; + return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; if (game_type < ADHOCCTL_GAMETYPE_1A || game_type > ADHOCCTL_GAMETYPE_2A || num_members < 2 || num_members > 16 || (game_type == ADHOCCTL_GAMETYPE_1A && num_members > 4)) - return ERROR_NET_ADHOCCTL_INVALID_ARG; + return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; deleteAllGMB(); gameModePeerPorts.clear(); @@ -2851,7 +2851,7 @@ int NetAdhocctl_CreateEnterGameMode(const char* group_name, int game_type, int n // 3). PtpSend (data=0x09F20E18, dataSizeAddr=0x09FE2094, timeout=0x627EDA, nonblock=0x0) - not sure what kind of data nor the size (more than 6 bytes) // 4). PtpFlush (timeout=0x2DC6C0, nonblock=0x0) // 5 & 6). PtpClose (accepted socket & listen socket) - // When timeout reached, notify user-defined Adhocctl Handlers with ERROR event (ERROR_NET_ADHOC_TIMEOUT) instead of GAMEMODE event + // When timeout reached, notify user-defined Adhocctl Handlers with ERROR event (SCE_NET_ADHOC_ERROR_TIMEOUT) instead of GAMEMODE event // We have to wait for all the MACs to have joined to go into CONNECTED state adhocctlCurrentMode = ADHOCCTL_MODE_GAMEMODE; @@ -2899,10 +2899,10 @@ static int sceNetAdhocctlJoinEnterGameMode(const char * group_name, const char * WARN_LOG_REPORT_ONCE(sceNetAdhocctlJoinEnterGameMode, Log::sceNet, "UNTESTED sceNetAdhocctlJoinEnterGameMode(%s, %s, %i, %i) at %08x", grpName, mac2str((SceNetEtherAddr*)hostMac).c_str(), timeout, flag, currentMIPS->pc); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (!hostMac) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); deleteAllGMB(); @@ -2914,7 +2914,7 @@ static int sceNetAdhocctlJoinEnterGameMode(const char * group_name, const char * // 2). PtpConnect (timeout=0x874CAC, nonblock=0x0) - to host/creator // 3). PtpRecv (data=0x09F20E18, dataSizeAddr=0x09FE2044, timeout=0x647553, nonblock=0x0) - repeated until data fully received with data address/offset adjusted (increased) and timeout adjusted (decreased), probably also adjusted data size (decreased) on each call // 4). PtpClose - // When timeout reached, notify user-defined Adhocctl Handlers with ERROR event (ERROR_NET_ADHOC_TIMEOUT) instead of GAMEMODE event + // When timeout reached, notify user-defined Adhocctl Handlers with ERROR event (SCE_NET_ADHOC_ERROR_TIMEOUT) instead of GAMEMODE event adhocctlCurrentMode = ADHOCCTL_MODE_GAMEMODE; adhocConnectionType = ADHOC_JOIN; @@ -3069,11 +3069,11 @@ static int sceNetAdhocGetPdpStat(u32 structSize, u32 structAddr) { } // Invalid Arguments - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg, at %08x", currentMIPS->pc); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg, at %08x", currentMIPS->pc); } // Library is uninitialized - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized, at %08x", currentMIPS->pc); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized, at %08x", currentMIPS->pc); } @@ -3177,18 +3177,18 @@ static int sceNetAdhocGetPtpStat(u32 structSize, u32 structAddr) { } // Invalid Arguments - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg, at %08x", currentMIPS->pc); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg, at %08x", currentMIPS->pc); } // Library is uninitialized - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized, at %08x", currentMIPS->pc); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized, at %08x", currentMIPS->pc); } int RecreatePtpSocket(int ptpId) { auto sock = adhocSockets[ptpId - 1]; if (!sock) { - return ERROR_NET_ADHOC_SOCKET_ID_NOT_AVAIL; + return SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL; } // Close old socket @@ -3204,7 +3204,7 @@ int RecreatePtpSocket(int ptpId) { // Valid Socket produced if (tcpsocket < 0) - return ERROR_NET_ADHOC_SOCKET_ID_NOT_AVAIL; + return SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL; // Update posix socket fd sock->data.ptp.id = tcpsocket; @@ -3306,7 +3306,7 @@ static int sceNetAdhocPtpOpen(const char *srcmac, int sport, const char *dstmac, // Dissidia 012 will try to reOpen the port without Closing the old one first when PtpConnect failed to try again. if (isPTPPortInUse(sport, false, daddr, dport)) { // FIXME: When PORT_IN_USE error occured it seems the index to the socket id also increased, which means it tries to create & bind the socket first and then closes it due to failed to bind - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_IN_USE, "port in use"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_IN_USE, "port in use"); } // Random Port required @@ -3448,20 +3448,20 @@ static int sceNetAdhocPtpOpen(const char *srcmac, int sport, const char *dstmac, closesocket(tcpsocket); // Port not available (exclusively in use?) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_NOT_AVAIL, "port not available"); // ERROR_NET_ADHOC_PORT_IN_USE; // ERROR_NET_ADHOC_INVALID_PORT; + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL, "port not available"); // SCE_NET_ADHOC_ERROR_PORT_IN_USE; // SCE_NET_ADHOC_ERROR_INVALID_PORT; } } // Invalid Arguments - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Invalid Addresses - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ADDR, "invalid address"); // ERROR_NET_ADHOC_INVALID_ARG; + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ADDR, "invalid address"); // SCE_NET_ADHOC_ERROR_INVALID_ARG; } // Library is uninitialized - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "adhoc not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "adhoc not initialized"); } // On a POSIX accept, returned socket may inherits properties from the listening socket, does PtpAccept also have similar behavior? @@ -3614,7 +3614,7 @@ static int sceNetAdhocPtpAccept(int id, u32 peerMacAddrPtr, u32 peerPortPtr, int if (socket->flags & ADHOC_F_ALERTACCEPT) { socket->alerted_flags |= ADHOC_F_ALERTACCEPT; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Listener Socket @@ -3655,26 +3655,26 @@ static int sceNetAdhocPtpAccept(int id, u32 peerMacAddrPtr, u32 peerPortPtr, int // Action would block if (flag) - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); // Timeout - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_TIMEOUT, "timeout"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_TIMEOUT, "timeout"); } // Client Socket - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_NOT_LISTENED, "not listened"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_LISTENED, "not listened"); } // Invalid Socket - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Invalid Arguments - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Library is uninitialized - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } int NetAdhocPtp_Connect(int id, int timeout, int flag, bool allowForcedConnect) { @@ -3691,7 +3691,7 @@ int NetAdhocPtp_Connect(int id, int timeout, int flag, bool allowForcedConnect) if (socket->flags & ADHOC_F_ALERTCONNECT) { socket->alerted_flags |= ADHOC_F_ALERTCONNECT; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Phantasy Star Portable 2 will try to reconnect even when previous connect already success, so we should return success too if it's already connected @@ -3767,7 +3767,7 @@ int NetAdhocPtp_Connect(int id, int timeout, int flag, bool allowForcedConnect) // Simulate blocking behaviour with non-blocking socket u64 threadSocketId = ((u64)__KernelGetCurThread()) << 32 | ptpsocket.id; if (sendTargetPeers.find(threadSocketId) != sendTargetPeers.end()) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_BUSY, "Socket %d is busy!", ptpsocket.id); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_BUSY, "Socket %d is busy!", ptpsocket.id); } AdhocSendTargets dest = { 0, {}, false }; @@ -3777,27 +3777,27 @@ int NetAdhocPtp_Connect(int id, int timeout, int flag, bool allowForcedConnect) } // NonBlocking Mode else { - // Returning WOULD_BLOCK as Workaround for ERROR_NET_ADHOC_CONNECTION_REFUSED to be more cross-platform, since there is no way to simulate ERROR_NET_ADHOC_CONNECTION_REFUSED properly on Windows - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + // Returning WOULD_BLOCK as Workaround for SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED to be more cross-platform, since there is no way to simulate SCE_NET_ADHOC_ERROR_CONNECTION_REFUSED properly on Windows + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); } } } } // Peer not found - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ADDR, "invalid address"); // ERROR_NET_ADHOC_WOULD_BLOCK / ERROR_NET_ADHOC_TIMEOUT + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ADDR, "invalid address"); // SCE_NET_ADHOC_ERROR_WOULD_BLOCK / SCE_NET_ADHOC_ERROR_TIMEOUT } // Not a valid Client Socket - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_OPENED, "not opened"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_OPENED, "not opened"); } // Invalid Socket - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Library is uninitialized - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } /** @@ -3844,15 +3844,15 @@ int NetAdhocPtp_Close(int id, int unknown) { return 0; } - return ERROR_NET_ADHOC_INVALID_SOCKET_ID; + return SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID; } // Invalid Argument - return ERROR_NET_ADHOC_INVALID_ARG; + return SCE_NET_ADHOC_ERROR_INVALID_ARG; } // Library is uninitialized - return ERROR_NET_ADHOC_NOT_INITIALIZED; + return SCE_NET_ADHOC_ERROR_NOT_INITIALIZED; } /** @@ -3900,7 +3900,7 @@ static int sceNetAdhocPtpListen(const char *srcmac, int sport, int bufsize, int // It's allowed to Listen and Open the same PTP port, But it's not allowed to Listen or Open the same PTP port twice. if (isPTPPortInUse(sport, true)) { // FIXME: When PORT_IN_USE error occured it seems the index to the socket id also increased, which means it tries to create & bind the socket first and then closes it due to failed to bind - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_IN_USE, "port in use"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_IN_USE, "port in use"); } // Random Port required @@ -4037,23 +4037,23 @@ static int sceNetAdhocPtpListen(const char *srcmac, int sport, int bufsize, int closesocket(tcpsocket); // Port not available (exclusively in use?) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_PORT_NOT_AVAIL, "port not available"); //ERROR_NET_ADHOC_PORT_IN_USE; // ERROR_NET_ADHOC_INVALID_PORT; + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_PORT_NOT_AVAIL, "port not available"); //SCE_NET_ADHOC_ERROR_PORT_IN_USE; // SCE_NET_ADHOC_ERROR_INVALID_PORT; } // Socket not available - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ID_NOT_AVAIL, "socket id not available"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ID_NOT_AVAIL, "socket id not available"); } // Invalid Arguments - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Invalid Addresses - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ADDR, "invalid address"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ADDR, "invalid address"); } // Library is uninitialized - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "adhoc not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "adhoc not initialized"); } /** @@ -4093,7 +4093,7 @@ static int sceNetAdhocPtpSend(int id, u32 dataAddr, u32 dataSizeAddr, int timeou if (socket->flags & ADHOC_F_ALERTSEND) { socket->alerted_flags |= ADHOC_F_ALERTSEND; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Acquire Network Lock @@ -4126,7 +4126,7 @@ static int sceNetAdhocPtpSend(int id, u32 dataAddr, u32 dataSizeAddr, int timeou else if (sent == SOCKET_ERROR && (error == EAGAIN || error == EWOULDBLOCK || (ptpsocket.state == ADHOC_PTP_STATE_SYN_SENT && (error == ENOTCONN || connectInProgress(error))))) { // Non-Blocking if (flag) - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); // Simulate blocking behaviour with non-blocking socket u64 threadSocketId = ((u64)__KernelGetCurThread()) << 32 | ptpsocket.id; @@ -4139,23 +4139,23 @@ static int sceNetAdhocPtpSend(int id, u32 dataAddr, u32 dataSizeAddr, int timeou ptpsocket.state = ADHOC_PTP_STATE_CLOSED; // Disconnected - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_DISCONNECTED, "disconnected"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_DISCONNECTED, "disconnected"); } // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); } // Not Connected - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CONNECTED, "not connected"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CONNECTED, "not connected"); } // Invalid Socket - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Library is uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } /** @@ -4194,7 +4194,7 @@ static int sceNetAdhocPtpRecv(int id, u32 dataAddr, u32 dataSizeAddr, int timeou if (socket->flags & ADHOC_F_ALERTRECV) { socket->alerted_flags |= ADHOC_F_ALERTRECV; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Acquire Network Lock @@ -4215,7 +4215,7 @@ static int sceNetAdhocPtpRecv(int id, u32 dataAddr, u32 dataSizeAddr, int timeou return WaitBlockingAdhocSocket(threadSocketId, PTP_RECV, id, buf, len, timeout, nullptr, nullptr, "ptp recv"); } - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); } // Free Network Lock @@ -4253,23 +4253,23 @@ static int sceNetAdhocPtpRecv(int id, u32 dataAddr, u32 dataSizeAddr, int timeou ptpsocket.state = ADHOC_PTP_STATE_CLOSED; // Disconnected - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_DISCONNECTED, "disconnected"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_DISCONNECTED, "disconnected"); } // Not Connected - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CONNECTED, "not connected"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CONNECTED, "not connected"); } // Invalid Socket - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid socket arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid socket arg"); } // Library is uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } int FlushPtpSocket(int socketId) { @@ -4313,7 +4313,7 @@ static int sceNetAdhocPtpFlush(int id, int timeout, int nonblock) { if (socket->flags & ADHOC_F_ALERTFLUSH) { socket->alerted_flags |= ADHOC_F_ALERTFLUSH; - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_SOCKET_ALERTED, "socket alerted"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_SOCKET_ALERTED, "socket alerted"); } // Connected Socket @@ -4328,7 +4328,7 @@ static int sceNetAdhocPtpFlush(int id, int timeout, int nonblock) { if (error == EAGAIN || error == EWOULDBLOCK) { // Non-Blocking if (nonblock) - return hleLogVerbose(Log::sceNet, ERROR_NET_ADHOC_WOULD_BLOCK, "would block"); + return hleLogVerbose(Log::sceNet, SCE_NET_ADHOC_ERROR_WOULD_BLOCK, "would block"); // Simulate blocking behaviour with non-blocking socket u64 threadSocketId = ((u64)__KernelGetCurThread()) << 32 | ptpsocket.id; @@ -4344,10 +4344,10 @@ static int sceNetAdhocPtpFlush(int id, int timeout, int nonblock) { } // Invalid Socket - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); } // Library uninitialized - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_INITIALIZED, "not initialized"); } /** @@ -4361,19 +4361,19 @@ static int sceNetAdhocPtpFlush(int id, int timeout, int nonblock) { static int sceNetAdhocGameModeCreateMaster(u32 dataAddr, int size) { WARN_LOG(Log::sceNet, "UNTESTED sceNetAdhocGameModeCreateMaster(%08x, %i) at %08x", dataAddr, size, currentMIPS->pc); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (adhocctlCurrentMode != ADHOCCTL_MODE_GAMEMODE) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_IN_GAMEMODE, "not in gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE, "not in gamemode"); if (!netAdhocGameModeEntered) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_ENTER_GAMEMODE, "not enter gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE, "not enter gamemode"); if (size < 0 || !Memory::IsValidAddress(dataAddr)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); if (masterGameModeArea.data) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_ALREADY_CREATED, "already created"); // FIXME: Should we return a success instead? (need to test this on a homebrew) + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_ALREADY_CREATED, "already created"); // FIXME: Should we return a success instead? (need to test this on a homebrew) hleEatMicro(1000); SceNetEtherAddr localMac; @@ -4399,7 +4399,7 @@ static int sceNetAdhocGameModeCreateMaster(u32 dataAddr, int size) { return hleLogDebug(Log::sceNet, 0, "success"); // returned an id just like CreateReplica? always return 0? } - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CREATED, "not created"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CREATED, "not created"); } /** @@ -4414,16 +4414,16 @@ static int sceNetAdhocGameModeCreateMaster(u32 dataAddr, int size) { static int sceNetAdhocGameModeCreateReplica(const char *mac, u32 dataAddr, int size) { WARN_LOG(Log::sceNet, "UNTESTED sceNetAdhocGameModeCreateReplica(%s, %08x, %i) at %08x", mac2str((SceNetEtherAddr*)mac).c_str(), dataAddr, size, currentMIPS->pc); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (adhocctlCurrentMode != ADHOCCTL_MODE_GAMEMODE) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_IN_GAMEMODE, "not in gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE, "not in gamemode"); if (!netAdhocGameModeEntered) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_ENTER_GAMEMODE, "not enter gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE, "not enter gamemode"); if (mac == nullptr || size < 0 || !Memory::IsValidAddress(dataAddr)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); hleEatMicro(1000); int maxid = 0; @@ -4435,7 +4435,7 @@ static int sceNetAdhocGameModeCreateReplica(const char *mac, u32 dataAddr, int s // MAC address already existed! if (it != replicaGameModeAreas.end()) { WARN_LOG(Log::sceNet, "sceNetAdhocGameModeCreateReplica - [%s] is already existed (id: %d)", mac2str((SceNetEtherAddr*)mac).c_str(), it->id); - return it->id; // ERROR_NET_ADHOC_ALREADY_CREATED + return it->id; // SCE_NET_ADHOC_ERROR_ALREADY_CREATED } int ret = 0; @@ -4462,19 +4462,19 @@ static int sceNetAdhocGameModeCreateReplica(const char *mac, u32 dataAddr, int s return hleLogInfo(Log::sceNet, ret, "success"); } - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CREATED, "not created"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CREATED, "not created"); } static int sceNetAdhocGameModeUpdateMaster() { DEBUG_LOG(Log::sceNet, "UNTESTED sceNetAdhocGameModeUpdateMaster() at %08x", currentMIPS->pc); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (adhocctlCurrentMode != ADHOCCTL_MODE_GAMEMODE) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_IN_GAMEMODE, "not in gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE, "not in gamemode"); if (!netAdhocGameModeEntered) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_ENTER_GAMEMODE, "not enter gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE, "not enter gamemode"); if (masterGameModeArea.data) { Memory::Memcpy(masterGameModeArea.data, masterGameModeArea.addr, masterGameModeArea.size); @@ -4514,7 +4514,7 @@ int NetAdhocGameMode_DeleteMaster() { static int sceNetAdhocGameModeDeleteMaster() { WARN_LOG(Log::sceNet, "UNTESTED sceNetAdhocGameModeDeleteMaster() at %08x", currentMIPS->pc); if (isZeroMAC(&masterGameModeArea.mac)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CREATED, "not created"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CREATED, "not created"); return NetAdhocGameMode_DeleteMaster(); } @@ -4522,13 +4522,13 @@ static int sceNetAdhocGameModeDeleteMaster() { static int sceNetAdhocGameModeUpdateReplica(int id, u32 infoAddr) { DEBUG_LOG(Log::sceNet, "UNTESTED sceNetAdhocGameModeUpdateReplica(%i, %08x) at %08x", id, infoAddr, currentMIPS->pc); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (adhocctlCurrentMode != ADHOCCTL_MODE_GAMEMODE) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_IN_GAMEMODE, "not in gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_IN_GAMEMODE, "not in gamemode"); if (!netAdhocGameModeEntered) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_ENTER_GAMEMODE, "not enter gamemode"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_ENTER_GAMEMODE, "not enter gamemode"); auto it = std::find_if(replicaGameModeAreas.begin(), replicaGameModeAreas.end(), [id](GameModeArea const& e) { @@ -4536,7 +4536,7 @@ static int sceNetAdhocGameModeUpdateReplica(int id, u32 infoAddr) { }); if (it == replicaGameModeAreas.end()) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CREATED, "not created"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CREATED, "not created"); // Bomberman Panic Bomber is using 0/null on infoAddr, so i guess it's optional. GameModeUpdateInfo* gmuinfo = NULL; @@ -4576,7 +4576,7 @@ static int sceNetAdhocGameModeDeleteReplica(int id) { }); if (it == replicaGameModeAreas.end()) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_NOT_CREATED, "not created"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_ERROR_NOT_CREATED, "not created"); if (it->data) { free(it->data); @@ -4597,10 +4597,10 @@ static int sceNetAdhocGameModeDeleteReplica(int id) { int sceNetAdhocGetSocketAlert(int id, u32 flagPtr) { WARN_LOG_REPORT_ONCE(sceNetAdhocGetSocketAlert, Log::sceNet, "UNTESTED sceNetAdhocGetSocketAlert(%i, %08x) at %08x", id, flagPtr, currentMIPS->pc); if (!Memory::IsValidAddress(flagPtr)) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_ARG, "invalid arg"); if (id < 1 || id > MAX_SOCKET || adhocSockets[id - 1] == NULL) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_INVALID_SOCKET_ID, "invalid socket id"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_ERROR_INVALID_SOCKET_ID, "invalid socket id"); s32_le flg = adhocSockets[id - 1]->flags; Memory::Write_U32(flg, flagPtr); @@ -4753,10 +4753,10 @@ static int sceNetAdhocctlExitGameMode() { static int sceNetAdhocctlGetGameModeInfo(u32 infoAddr) { DEBUG_LOG(Log::sceNet, "sceNetAdhocctlGetGameModeInfo(%08x)", infoAddr); if (!netAdhocctlInited) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); if (!Memory::IsValidAddress(infoAddr)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); SceNetAdhocctlGameModeInfo* gmInfo = (SceNetAdhocctlGameModeInfo*)Memory::GetPointer(infoAddr); // Writes number of participants and each participating MAC address into infoAddr/gmInfo @@ -4860,11 +4860,11 @@ static int sceNetAdhocctlGetPeerList(u32 sizeAddr, u32 bufAddr) { } // Invalid Arguments - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG, "invalid arg"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG, "invalid arg"); } // Uninitialized Library - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOCCTL_NOT_INITIALIZED, "not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED, "not initialized"); } static int sceNetAdhocctlGetAddrByName(const char *nickName, u32 sizeAddr, u32 bufAddr) { @@ -4872,7 +4872,7 @@ static int sceNetAdhocctlGetAddrByName(const char *nickName, u32 sizeAddr, u32 b if (Memory::IsValidAddress(sizeAddr)) buflen = (s32_le *)Memory::GetPointer(sizeAddr); if (!nickName || !buflen) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOCCTL_INVALID_ARG); + return hleLogError(Log::sceNet, SCE_NET_ADHOCCTL_ERROR_INVALID_ARG); } char nckName[ADHOCCTL_NICKNAME_LEN]; @@ -4979,11 +4979,11 @@ static int sceNetAdhocctlGetAddrByName(const char *nickName, u32 sizeAddr, u32 b } // Invalid Arguments - return ERROR_NET_ADHOCCTL_INVALID_ARG; + return SCE_NET_ADHOCCTL_ERROR_INVALID_ARG; } // Library uninitialized - return ERROR_NET_ADHOCCTL_NOT_INITIALIZED; + return SCE_NET_ADHOCCTL_ERROR_NOT_INITIALIZED; } const HLEFunction sceNetAdhocctl[] = { diff --git a/Core/HLE/sceNetAdhocMatching.cpp b/Core/HLE/sceNetAdhocMatching.cpp index f4a577937e..bc75b56fd7 100644 --- a/Core/HLE/sceNetAdhocMatching.cpp +++ b/Core/HLE/sceNetAdhocMatching.cpp @@ -1695,7 +1695,7 @@ int sceNetAdhocMatchingInit(u32 memsize) { // Uninitialized Library if (netAdhocMatchingInited) - return ERROR_NET_ADHOC_MATCHING_ALREADY_INITIALIZED; + return SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_INITIALIZED; // Save Fake Pool Size fakePoolSize = memsize; @@ -1748,22 +1748,22 @@ static int sceNetAdhocMatchingCreate(int mode, int maxnum, int port, int rxbufle if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhoc matching not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhoc matching not initialized"); } if (maxnum <= 1 || maxnum > 16) { // Invalid Member Limit - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_MAXNUM, "adhoc matching invalid maxnum"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MAXNUM, "adhoc matching invalid maxnum"); } if (rxbuflen < 1) { // Invalid Receive Buffer Size - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_RXBUF_TOO_SHORT, "adhoc matching rxbuf too short"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_RXBUF_TOO_SHORT, "adhoc matching rxbuf too short"); } if (mode < 1 || mode > 3) { // InvalidERROR_NET_Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhoc matching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhoc matching invalid arg"); } // Iterate Matching Contexts @@ -1771,7 +1771,7 @@ static int sceNetAdhocMatchingCreate(int mode, int maxnum, int port, int rxbufle for (; item != NULL; item = item->next) { // Port Match found if (item->port == port) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_PORT_IN_USE, "adhoc matching port in use"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_PORT_IN_USE, "adhoc matching port in use"); } // Allocate Context Memory @@ -1846,7 +1846,7 @@ static int sceNetAdhocMatchingCreate(int mode, int maxnum, int port, int rxbufle } // Out of Memory - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NO_SPACE, "adhoc matching no space"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE, "adhoc matching no space"); } int NetAdhocMatching_Start(int matchingId, int evthPri, int evthPartitionId, int evthStack, int inthPri, int inthPartitionId, int inthStack, int optLen, u32 optDataAddr) { @@ -1856,7 +1856,7 @@ int NetAdhocMatching_Start(int matchingId, int evthPri, int evthPartitionId, int SceNetAdhocMatchingContext* item = findMatchingContext(matchingId); if (item == NULL) { - // return ERROR_NET_ADHOC_MATCHING_INVALID_ID; //Faking success to prevent GTA:VCS from stuck unable to choose host/join menu + // return SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID; //Faking success to prevent GTA:VCS from stuck unable to choose host/join menu return hleLogDebug(Log::sceNet, 0); } @@ -1870,15 +1870,15 @@ int NetAdhocMatching_Start(int matchingId, int evthPri, int evthPartitionId, int item->hellolen = optLen; item->helloAddr = optDataAddr; } - //else return ERROR_NET_ADHOC_MATCHING_NO_SPACE; //Faking success to prevent GTA:VCS from stuck unable to choose host/join menu + //else return SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE; //Faking success to prevent GTA:VCS from stuck unable to choose host/join menu } - //else return ERROR_NET_ADHOC_MATCHING_INVALID_ARG; // ERROR_NET_ADHOC_MATCHING_INVALID_OPTLEN; // Returning Not Success will cause GTA:VC stuck unable to choose host/join menu + //else return SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG; // SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN; // Returning Not Success will cause GTA:VC stuck unable to choose host/join menu // Create PDP Socket int sock = hleCall(sceNetAdhoc, int, sceNetAdhocPdpCreate, (const char*)&item->mac, static_cast(item->port), item->rxbuflen, 0); item->socket = sock; if (sock < 1) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_PORT_IN_USE, "adhoc matching port in use"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_PORT_IN_USE, "adhoc matching port in use"); } // Create & Start the Fake PSP Thread ("matching_ev%d" and "matching_io%d") @@ -1944,12 +1944,12 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); } if (macAddress == NULL) { // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); } SceNetEtherAddr * target = (SceNetEtherAddr *)macAddress; @@ -1959,12 +1959,12 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres if (context == NULL) { // Invalid Matching ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "adhocmatching invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "adhocmatching invalid id"); } if (!context->running) { // Idle Context - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "adhocmatching not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "adhocmatching not running"); } // Search Result @@ -1972,12 +1972,12 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres if (peer == NULL) { // Peer not found - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET, "adhocmatching unknown target"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET, "adhocmatching unknown target"); } if ((optLen != 0) && (optLen <= 0 || optDataPtr == 0)) { // Invalid Optional Data Length - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_OPTLEN, "adhocmatching invalid optlen"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN, "adhocmatching invalid optlen"); } void * opt = NULL; @@ -1985,10 +1985,10 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres // Host Mode if (context->mode == PSP_ADHOC_MATCHING_MODE_PARENT) { // Already Connected - if (peer->state == PSP_ADHOC_MATCHING_PEER_CHILD) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_ALREADY_ESTABLISHED, "adhocmatching already established"); + if (peer->state == PSP_ADHOC_MATCHING_PEER_CHILD) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED, "adhocmatching already established"); // Not enough space - if (countChildren(context) == (context->maxpeers - 1)) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_EXCEED_MAXNUM, "adhocmatching exceed maxnum"); + if (countChildren(context) == (context->maxpeers - 1)) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_EXCEED_MAXNUM, "adhocmatching exceed maxnum"); // Requesting Peer if (peer->state == PSP_ADHOC_MATCHING_PEER_INCOMING_REQUEST) { @@ -2014,10 +2014,10 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres // Client Mode else if (context->mode == PSP_ADHOC_MATCHING_MODE_CHILD) { // Already connected - if (findParent(context) != NULL) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_ALREADY_ESTABLISHED, "adhocmatching already established"); + if (findParent(context) != NULL) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED, "adhocmatching already established"); // Outgoing Request in Progress - if (findOutgoingRequest(context) != NULL) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_REQUEST_IN_PROGRESS, "adhocmatching request in progress"); + if (findOutgoingRequest(context) != NULL) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_REQUEST_IN_PROGRESS, "adhocmatching request in progress"); // Valid Offer if (peer->state == PSP_ADHOC_MATCHING_PEER_OFFER) { @@ -2035,10 +2035,10 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres // P2P Mode else { // Already connected - if (findP2P(context) != NULL) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_ALREADY_ESTABLISHED, "adhocmatching already established"); + if (findP2P(context) != NULL) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_ALREADY_ESTABLISHED, "adhocmatching already established"); // Outgoing Request in Progress - if (findOutgoingRequest(context) != NULL) return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_REQUEST_IN_PROGRESS, "adhocmatching request in progress"); + if (findOutgoingRequest(context) != NULL) return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_REQUEST_IN_PROGRESS, "adhocmatching request in progress"); // Join Request Mode if (peer->state == PSP_ADHOC_MATCHING_PEER_OFFER) { @@ -2068,13 +2068,13 @@ static int sceNetAdhocMatchingSelectTarget(int matchingId, const char *macAddres } // How did this happen?! It shouldn't! - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_TARGET_NOT_READY, "adhocmatching target not ready"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_TARGET_NOT_READY, "adhocmatching target not ready"); } int NetAdhocMatching_CancelTargetWithOpt(int matchingId, const char* macAddress, int optLen, u32 optDataPtr) { if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); } SceNetEtherAddr* target = (SceNetEtherAddr*)macAddress; @@ -2083,7 +2083,7 @@ int NetAdhocMatching_CancelTargetWithOpt(int matchingId, const char* macAddress, if (target == NULL || ((optLen != 0) && (optLen <= 0 || opt == NULL))) { // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); } // Find Matching Context @@ -2091,12 +2091,12 @@ int NetAdhocMatching_CancelTargetWithOpt(int matchingId, const char* macAddress, if (context == NULL) { // Invalid Matching ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "adhocmatching invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "adhocmatching invalid id"); } if (!context->running) { // Context not running - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "adhocmatching not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "adhocmatching not running"); } // Find Peer @@ -2104,7 +2104,7 @@ int NetAdhocMatching_CancelTargetWithOpt(int matchingId, const char* macAddress, if (peer == NULL) { // Peer not found - //return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET, "adhocmatching unknown target"); + //return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET, "adhocmatching unknown target"); // Faking success to prevent the game (ie. Soul Calibur) to repeatedly calling this function when the other player is disconnected return hleLogDebug(Log::sceNet, 0); } @@ -2138,7 +2138,7 @@ int NetAdhocMatching_CancelTargetWithOpt(int matchingId, const char* macAddress, } // Peer not found - //return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET, "adhocmatching unknown target"); + //return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET, "adhocmatching unknown target"); // Faking success to prevent the game (ie. Soul Calibur) to repeatedly calling this function when the other player is disconnected return hleLogDebug(Log::sceNet, 0); } @@ -2165,7 +2165,7 @@ int sceNetAdhocMatchingGetHelloOpt(int matchingId, u32 optLenAddr, u32 optDataAd } if (!Memory::IsValidAddress(optLenAddr)) { - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG); } s32_le *optlen = PSPPointer::Create(optLenAddr); @@ -2182,9 +2182,9 @@ int sceNetAdhocMatchingGetHelloOpt(int matchingId, u32 optLenAddr, u32 optDataAd uint8_t * optdata = Memory::GetPointerWriteUnchecked(optDataAddr); memcpy(optdata, item->hello, *optlen); } - //else return ERROR_NET_ADHOC_MATCHING_INVALID_ARG; + //else return SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG; } - //else return ERROR_NET_ADHOC_MATCHING_INVALID_ID; + //else return SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID; // Multithreading Unlock peerlock.unlock(); @@ -2198,7 +2198,7 @@ int sceNetAdhocMatchingSetHelloOpt(int matchingId, int optLenAddr, u32 optDataAd } if (!netAdhocMatchingInited) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); // Multithreading Lock peerlock.lock(); @@ -2210,19 +2210,19 @@ int sceNetAdhocMatchingSetHelloOpt(int matchingId, int optLenAddr, u32 optDataAd // Context not found if (context == NULL) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "adhocmatching invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "adhocmatching invalid id"); // Invalid Matching Mode (Child) if (context->mode == PSP_ADHOC_MATCHING_MODE_CHILD) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_MODE, "adhocmatching invalid mode"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_MODE, "adhocmatching invalid mode"); // Context not running if (!context->running) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "adhocmatching not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "adhocmatching not running"); // Invalid Optional Data Length if ((optLenAddr != 0) && (optDataAddr == 0)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_OPTLEN, "adhocmatching invalid optlen"); //ERROR_NET_ADHOC_MATCHING_INVALID_ARG + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_OPTLEN, "adhocmatching invalid optlen"); //SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG // Grab Existing Hello Data void* hello = context->hello; @@ -2240,7 +2240,7 @@ int sceNetAdhocMatchingSetHelloOpt(int matchingId, int optLenAddr, u32 optDataAd // Out of Memory if (hello == NULL) { context->hellolen = 0; - return ERROR_NET_ADHOC_MATCHING_NO_SPACE; + return SCE_NET_ADHOC_MATCHING_ERROR_NO_SPACE; } // Clone Hello Data @@ -2270,11 +2270,11 @@ static int sceNetAdhocMatchingGetMembers(int matchingId, u32 sizeAddr, u32 buf) } if (!netAdhocMatchingInited) - return hleLogDebug(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogDebug(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); // Minimum Argument if (!Memory::IsValidAddress(sizeAddr)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); // Multithreading Lock peerlock.lock(); @@ -2285,15 +2285,15 @@ static int sceNetAdhocMatchingGetMembers(int matchingId, u32 sizeAddr, u32 buf) // Context not found if (context == NULL) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "adhocmatching invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "adhocmatching invalid id"); // Context not running if (!context->running) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "adhocmatching not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "adhocmatching not running"); // Buffer Length not available if (!Memory::IsValidAddress(sizeAddr)) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); int* buflen = (int*)Memory::GetPointer(sizeAddr); SceNetAdhocMatchingMemberInfoEmu* buf2 = NULL; @@ -2466,12 +2466,12 @@ int sceNetAdhocMatchingSendData(int matchingId, const char *mac, int dataLen, u3 if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "not initialized"); } if (mac == NULL) { // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "invalid arg"); } // Find Matching Context @@ -2479,18 +2479,18 @@ int sceNetAdhocMatchingSendData(int matchingId, const char *mac, int dataLen, u3 if (context == NULL) { // Invalid Matching ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "invalid id"); } if (!context->running) { // Context not running - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "not running"); } // Invalid Data Length if (dataLen <= 0 || dataAddr == 0) { // Invalid Data Length - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_DATALEN, "invalid datalen"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_DATALEN, "invalid datalen"); } void* data = NULL; @@ -2504,17 +2504,17 @@ int sceNetAdhocMatchingSendData(int matchingId, const char *mac, int dataLen, u3 if (peer == NULL) { // Peer not found - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET, "unknown target"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET, "unknown target"); } if (peer->state != PSP_ADHOC_MATCHING_PEER_PARENT && peer->state != PSP_ADHOC_MATCHING_PEER_CHILD && peer->state != PSP_ADHOC_MATCHING_PEER_P2P) { // Not connected / accepted - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_ESTABLISHED, "not established"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_ESTABLISHED, "not established"); } // Send in Progress if (peer->sending) - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_DATA_BUSY, "data busy"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_DATA_BUSY, "data busy"); // Mark Peer as Sending peer->sending = 1; @@ -2534,12 +2534,12 @@ int sceNetAdhocMatchingAbortSendData(int matchingId, const char *mac) { if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); } if (mac == NULL) { // Invalid Arguments - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); } // Find Matching Context @@ -2547,12 +2547,12 @@ int sceNetAdhocMatchingAbortSendData(int matchingId, const char *mac) { if (context == NULL) { // Invalid Matching ID - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ID, "adhocmatching invalid id"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ID, "adhocmatching invalid id"); } if (!context->running) { // Context not running - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_RUNNING, "adhocmatching not running"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_RUNNING, "adhocmatching not running"); } // Find Target Peer @@ -2560,7 +2560,7 @@ int sceNetAdhocMatchingAbortSendData(int matchingId, const char *mac) { if (peer == NULL) { // Peer not found - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_UNKNOWN_TARGET, "adhocmatching unknown target"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_UNKNOWN_TARGET, "adhocmatching unknown target"); } // Peer is sending @@ -2593,7 +2593,7 @@ int sceNetAdhocMatchingGetPoolStat(u32 poolstatPtr) { if (!netAdhocMatchingInited) { // Uninitialized Library - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_NOT_INITIALIZED, "adhocmatching not initialized"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_NOT_INITIALIZED, "adhocmatching not initialized"); } SceNetMallocStat * poolstat = NULL; @@ -2601,7 +2601,7 @@ int sceNetAdhocMatchingGetPoolStat(u32 poolstatPtr) { if (poolstat == NULL) { // Invalid Argument - return hleLogError(Log::sceNet, ERROR_NET_ADHOC_MATCHING_INVALID_ARG, "adhocmatching invalid arg"); + return hleLogError(Log::sceNet, SCE_NET_ADHOC_MATCHING_ERROR_INVALID_ARG, "adhocmatching invalid arg"); } // Fill Poolstat with Fake Data From a08b6c13403f56ac4789628011548bcb3592b1b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Wed, 6 Aug 2025 00:49:55 +0200 Subject: [PATCH 3/4] More error code cleanup --- Core/HLE/ErrorCodes.h | 14 ++++ Core/HLE/NetInetConstants.h | 138 ------------------------------------ Core/HLE/sceKernel.cpp | 2 + Core/HLE/sceNetInet.cpp | 3 +- 4 files changed, 18 insertions(+), 139 deletions(-) diff --git a/Core/HLE/ErrorCodes.h b/Core/HLE/ErrorCodes.h index f917f16d51..fdbba377fe 100644 --- a/Core/HLE/ErrorCodes.h +++ b/Core/HLE/ErrorCodes.h @@ -515,6 +515,20 @@ enum PSPErrorCode : u32 { SCE_MP3_ERROR_BAD_ADDR = 0x80671002, SCE_MP3_ERROR_BAD_SIZE = 0x80671003, + // pspnet_inet + SCE_NET_INET_ERROR_ALREADY_INITIALIZED = 0x80410201, + // Are these used? + SCE_NET_INET_ERROR_SOCKET_BUSY = 0x80410202, + SCE_NET_INET_ERROR_CONFIG_INVALID_ARG = 0x80410203, + SCE_NET_INET_ERROR_GET_IFADDR = 0x80410204, + SCE_NET_INET_ERROR_SET_IFADDR = 0x80410205, + SCE_NET_INET_ERROR_DEL_IFADDR = 0x80410206, + SCE_NET_INET_ERROR_NO_DEFAULT_ROUTE = 0x80410207, + SCE_NET_INET_ERROR_GET_ROUTE = 0x80410208, + SCE_NET_INET_ERROR_SET_ROUTE = 0x80410209, + SCE_NET_INET_ERROR_FLUSH_ROUTE = 0x8041020a, + SCE_NET_INET_ERROR_INVALID_ARG = 0x8041020b, + // pspnet_resolver SCE_NET_RESOLVER_ERROR_NOT_TERMINATED = 0x80410401, SCE_NET_RESOLVER_ERROR_NO_DNS_SERVER = 0x80410402, diff --git a/Core/HLE/NetInetConstants.h b/Core/HLE/NetInetConstants.h index 595676d0f8..1ed42a84b9 100644 --- a/Core/HLE/NetInetConstants.h +++ b/Core/HLE/NetInetConstants.h @@ -302,144 +302,6 @@ enum { #define SHUT_RDWR SD_BOTH //0x02 #endif -enum { - // from pspsdk's pspnet.h which is similar to https://docs.vitasdk.org/net_2net_8h_source.html - SCE_NET_ERROR_EPERM = 0x80410101, - SCE_NET_ERROR_ENOENT = 0x80410102, - SCE_NET_ERROR_ESRCH = 0x80410103, - SCE_NET_ERROR_EINTR = 0x80410104, - SCE_NET_ERROR_EIO = 0x80410105, - SCE_NET_ERROR_ENXIO = 0x80410106, - SCE_NET_ERROR_E2BIG = 0x80410107, - - SCE_NET_ERROR_ENOEXEC = 0x80410108, - SCE_NET_ERROR_EBADF = 0x80410109, - SCE_NET_ERROR_ECHILD = 0x8041010A, - SCE_NET_ERROR_EDEADLK = 0x8041010B, - SCE_NET_ERROR_ENOMEM = 0x8041010C, - SCE_NET_ERROR_EACCES = 0x8041010D, - SCE_NET_ERROR_EFAULT = 0x8041010E, - SCE_NET_ERROR_ENOTBLK = 0x8041010F, - SCE_NET_ERROR_EBUSY = 0x80410110, - SCE_NET_ERROR_EEXIST = 0x80410111, - SCE_NET_ERROR_EXDEV = 0x80410112, - SCE_NET_ERROR_ENODEV = 0x80410113, - SCE_NET_ERROR_ENOTDIR = 0x80410114, - SCE_NET_ERROR_EISDIR = 0x80410115, - SCE_NET_ERROR_EINVAL = 0x80410116, - SCE_NET_ERROR_ENFILE = 0x80410117, - SCE_NET_ERROR_EMFILE = 0x80410118, - SCE_NET_ERROR_ENOTTY = 0x80410119, - SCE_NET_ERROR_ETXTBSY = 0x8041011A, - SCE_NET_ERROR_EFBIG = 0x8041011B, - SCE_NET_ERROR_ENOSPC = 0x8041011C, - SCE_NET_ERROR_ESPIPE = 0x8041011D, - SCE_NET_ERROR_EROFS = 0x8041011E, - SCE_NET_ERROR_EMLINK = 0x8041011F, - SCE_NET_ERROR_EPIPE = 0x80410120, - SCE_NET_ERROR_EDOM = 0x80410121, - SCE_NET_ERROR_ERANGE = 0x80410122, - SCE_NET_ERROR_EAGAIN = 0x80410123, - SCE_NET_ERROR_EWOULDBLOCK = 0x80410123, - SCE_NET_ERROR_EINPROGRESS = 0x80410124, - SCE_NET_ERROR_EALREADY = 0x80410125, - SCE_NET_ERROR_ENOTSOCK = 0x80410126, - SCE_NET_ERROR_EDESTADDRREQ = 0x80410127, - SCE_NET_ERROR_EMSGSIZE = 0x80410128, - SCE_NET_ERROR_EPROTOTYPE = 0x80410129, - SCE_NET_ERROR_ENOPROTOOPT = 0x8041012A, - SCE_NET_ERROR_EPROTONOSUPPORT = 0x8041012B, - SCE_NET_ERROR_ESOCKTNOSUPPORT = 0x8041012C, - SCE_NET_ERROR_EOPNOTSUPP = 0x8041012D, - SCE_NET_ERROR_EPFNOSUPPORT = 0x8041012E, - SCE_NET_ERROR_EAFNOSUPPORT = 0x8041012F, - SCE_NET_ERROR_EADDRINUSE = 0x80410130, - SCE_NET_ERROR_EADDRNOTAVAIL = 0x80410131, - SCE_NET_ERROR_ENETDOWN = 0x80410132, - SCE_NET_ERROR_ENETUNREACH = 0x80410133, - SCE_NET_ERROR_ENETRESET = 0x80410134, - SCE_NET_ERROR_ECONNABORTED = 0x80410135, - SCE_NET_ERROR_ECONNRESET = 0x80410136, - SCE_NET_ERROR_ENOBUFS = 0x80410137, - SCE_NET_ERROR_EISCONN = 0x80410138, - SCE_NET_ERROR_ENOTCONN = 0x80410139, - SCE_NET_ERROR_ESHUTDOWN = 0x8041013A, - SCE_NET_ERROR_ETOOMANYREFS = 0x8041013B, - SCE_NET_ERROR_ETIMEDOUT = 0x8041013C, - SCE_NET_ERROR_ECONNREFUSED = 0x8041013D, - SCE_NET_ERROR_ELOOP = 0x8041013E, - SCE_NET_ERROR_ENAMETOOLONG = 0x8041013F, - SCE_NET_ERROR_EHOSTDOWN = 0x80410140, - SCE_NET_ERROR_EHOSTUNREACH = 0x80410141, - SCE_NET_ERROR_ENOTEMPTY = 0x80410142, - SCE_NET_ERROR_EPROCLIM = 0x80410143, - SCE_NET_ERROR_EUSERS = 0x80410144, - SCE_NET_ERROR_EDQUOT = 0x80410145, - SCE_NET_ERROR_ESTALE = 0x80410146, - SCE_NET_ERROR_EREMOTE = 0x80410147, - SCE_NET_ERROR_EBADRPC = 0x80410148, - SCE_NET_ERROR_ERPCMISMATCH = 0x80410149, - SCE_NET_ERROR_EPROGUNAVAIL = 0x8041014A, - SCE_NET_ERROR_EPROGMISMATCH = 0x8041014B, - SCE_NET_ERROR_EPROCUNAVAIL = 0x8041014C, - SCE_NET_ERROR_ENOLCK = 0x8041014D, - SCE_NET_ERROR_ENOSYS = 0x8041014E, - SCE_NET_ERROR_EFTYPE = 0x8041014F, - SCE_NET_ERROR_EAUTH = 0x80410150, - SCE_NET_ERROR_ENEEDAUTH = 0x80410151, - SCE_NET_ERROR_EIDRM = 0x80410152, - SCE_NET_ERROR_ENOMS = 0x80410153, - SCE_NET_ERROR_EOVERFLOW = 0x80410154, - SCE_NET_ERROR_EILSEQ = 0x80410155, - SCE_NET_ERROR_ENOTSUP = 0x80410156, - SCE_NET_ERROR_ECANCELED = 0x80410157, - SCE_NET_ERROR_EBADMSG = 0x80410158, - SCE_NET_ERROR_ENODATA = 0x80410159, - SCE_NET_ERROR_ENOSR = 0x8041015A, - SCE_NET_ERROR_ENOSTR = 0x8041015B, - SCE_NET_ERROR_ETIME = 0x8041015C, - - SCE_NET_ERROR_EADHOC = 0x804101A0, - SCE_NET_ERROR_EDISABLEDIF = 0x804101A1, - SCE_NET_ERROR_ERESUME = 0x804101A2, - - SCE_NET_ERROR_ENOTINIT = 0x804101C8, - SCE_NET_ERROR_ENOLIBMEM = 0x804101C9, - SCE_NET_ERROR_ERESERVED202 = 0x804101CA, - SCE_NET_ERROR_ECALLBACK = 0x804101CB, - SCE_NET_ERROR_EINTERNAL = 0x804101CC, - SCE_NET_ERROR_ERETURN = 0x804101CD, - - SCE_NET_ERROR_RESOLVER_EINTERNAL = 0x804101DC, - SCE_NET_ERROR_RESOLVER_EBUSY = 0x804101DD, - SCE_NET_ERROR_RESOLVER_ENOSPACE = 0x804101DE, - SCE_NET_ERROR_RESOLVER_EPACKET = 0x804101DF, - SCE_NET_ERROR_RESOLVER_ERESERVED22 = 0x804101E0, - SCE_NET_ERROR_RESOLVER_ENODNS = 0x804101E1, - SCE_NET_ERROR_RESOLVER_ETIMEDOUT = 0x804101E2, - SCE_NET_ERROR_RESOLVER_ENOSUPPORT = 0x804101E3, - SCE_NET_ERROR_RESOLVER_EFORMAT = 0x804101E4, - SCE_NET_ERROR_RESOLVER_ESERVERFAILURE = 0x804101E5, - SCE_NET_ERROR_RESOLVER_ENOHOST = 0x804101E6, - SCE_NET_ERROR_RESOLVER_ENOTIMPLEMENTED = 0x804101E7, - SCE_NET_ERROR_RESOLVER_ESERVERREFUSED = 0x804101E8, - SCE_NET_ERROR_RESOLVER_ENORECORD = 0x804101E9, - SCE_NET_ERROR_RESOLVER_EALIGNMENT = 0x804101EA, - - // pspnet_inet - ERROR_NET_INET_ALREADY_INITIALIZED = 0x80410201, - ERROR_NET_INET_SOCKET_BUSY = 0x80410202, - ERROR_NET_INET_CONFIG_INVALID_ARG = 0x80410203, - ERROR_NET_INET_GET_IFADDR = 0x80410204, - ERROR_NET_INET_SET_IFADDR = 0x80410205, - ERROR_NET_INET_DEL_IFADDR = 0x80410206, - ERROR_NET_INET_NO_DEFAULT_ROUTE = 0x80410207, - ERROR_NET_INET_GET_ROUTE = 0x80410208, - ERROR_NET_INET_SET_ROUTE = 0x80410209, - ERROR_NET_INET_FLUSH_ROUTE = 0x8041020a, - ERROR_NET_INET_INVALID_ARG = 0x8041020b, -}; - int convertMsgFlagPSP2Host(int flag); int convertMsgFlagHost2PSP(int flag); int convertMSGFlagsPSP2Host(int flags); diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index 5dcd22479a..60b5132443 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -1512,6 +1512,8 @@ const char *KernelErrorToString(u32 err) { case SCE_MP3_ERROR_BAD_ADDR: return "SCE_MP3_ERROR_BAD_ADDR"; case SCE_MP3_ERROR_BAD_SIZE: return "SCE_MP3_ERROR_BAD_SIZE"; + case SCE_NET_INET_ERROR_ALREADY_INITIALIZED: return "SCE_NET_INET_ERROR_ALREADY_INITIALIZED"; + case SCE_NET_RESOLVER_ERROR_NOT_TERMINATED: return "SCE_NET_RESOLVER_ERROR_NOT_TERMINATED"; case SCE_NET_RESOLVER_ERROR_NO_DNS_SERVER: return "SCE_NET_RESOLVER_ERROR_NO_DNS_SERVER"; case SCE_NET_RESOLVER_ERROR_INVALID_PTR: return "SCE_NET_RESOLVER_ERROR_INVALID_PTR"; diff --git a/Core/HLE/sceNetInet.cpp b/Core/HLE/sceNetInet.cpp index faea20206f..aa8431742e 100644 --- a/Core/HLE/sceNetInet.cpp +++ b/Core/HLE/sceNetInet.cpp @@ -8,6 +8,7 @@ #include "Core/HLE/SocketManager.h" #include "Core/HLE/HLE.h" +#include "Core/HLE/ErrorCodes.h" #include "Core/HLE/FunctionWrappers.h" #include "Core/HLE/sceNet.h" #include "Core/HLE/sceNetAdhoc.h" @@ -69,7 +70,7 @@ void __NetInetShutdown() { static int sceNetInetInit() { if (netInetInited) - return hleLogError(Log::sceNet, ERROR_NET_INET_ALREADY_INITIALIZED); + return hleLogError(Log::sceNet, SCE_NET_INET_ERROR_ALREADY_INITIALIZED); g_inetLastErrno.clear(); netInetInited = true; return hleLogDebug(Log::sceNet, 0); From 7dde367ead4ac782363c0fd2052ba2019ff41253 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Wed, 6 Aug 2025 01:09:02 +0200 Subject: [PATCH 4/4] Improve logging in sceUtility *GetStatus functions --- Core/Dialog/PSPDialog.cpp | 12 +++++++++ Core/Dialog/PSPDialog.h | 1 + Core/Dialog/PSPScreenshotDialog.h | 1 - Core/HLE/sceUtility.cpp | 42 ++++++++++++++++--------------- 4 files changed, 35 insertions(+), 21 deletions(-) diff --git a/Core/Dialog/PSPDialog.cpp b/Core/Dialog/PSPDialog.cpp index d4a59f99b3..89c6fca625 100644 --- a/Core/Dialog/PSPDialog.cpp +++ b/Core/Dialog/PSPDialog.cpp @@ -51,6 +51,18 @@ const char *UtilityDialogTypeToString(UtilityDialogType type) { } } +const char *UtilityDialogStatusToString(PSPDialog::DialogStatus status) { + switch (status) { + case PSPDialog::SCE_UTILITY_STATUS_NONE: return "STATUS_NONE"; + case PSPDialog::SCE_UTILITY_STATUS_INITIALIZE: return "STATUS_INITIALIZE"; + case PSPDialog::SCE_UTILITY_STATUS_RUNNING: return "STATUS_RUNNING"; + case PSPDialog::SCE_UTILITY_STATUS_FINISHED: return "STATUS_FINISHED"; + case PSPDialog::SCE_UTILITY_STATUS_SHUTDOWN: return "STATUS_SHUTDOWN"; + case PSPDialog::SCE_UTILITY_STATUS_SCREENSHOT_UNKNOWN: return "STATUS_SCREENSHOT_UNKNOWN"; + default: return "(unknown)"; + } +} + void PSPDialog::InitCommon() { UpdateCommon(); diff --git a/Core/Dialog/PSPDialog.h b/Core/Dialog/PSPDialog.h index bfe032aff5..cf79855266 100644 --- a/Core/Dialog/PSPDialog.h +++ b/Core/Dialog/PSPDialog.h @@ -138,3 +138,4 @@ private: }; const char *UtilityDialogTypeToString(UtilityDialogType type); +const char *UtilityDialogStatusToString(PSPDialog::DialogStatus status); diff --git a/Core/Dialog/PSPScreenshotDialog.h b/Core/Dialog/PSPScreenshotDialog.h index 760cd8fcc7..f6195faec2 100644 --- a/Core/Dialog/PSPScreenshotDialog.h +++ b/Core/Dialog/PSPScreenshotDialog.h @@ -42,4 +42,3 @@ protected: int mode; PSPPointer params_; }; - diff --git a/Core/HLE/sceUtility.cpp b/Core/HLE/sceUtility.cpp index f3cd4bcee1..7668a68a38 100644 --- a/Core/HLE/sceUtility.cpp +++ b/Core/HLE/sceUtility.cpp @@ -45,6 +45,7 @@ #include "Core/HLE/sceUtility.h" #include "Core/HLE/sceNet.h" +#include "Core/Dialog/PSPDialog.h" #include "Core/Dialog/PSPSaveDialog.h" #include "Core/Dialog/PSPMsgDialog.h" #include "Core/Dialog/PSPPlaceholderDialog.h" @@ -158,6 +159,7 @@ static PSPScreenshotDialog *screenshotDialog; static PSPGamedataInstallDialog *gamedataInstallDialog; static PSPNpSigninDialog *npSigninDialog; +// A lot of state seems to be shared between the various dialog types. static int oldStatus = -1; static std::map currentlyLoadedModules; static int volatileUnlockEvent = -1; @@ -473,14 +475,14 @@ static int sceUtilitySavedataGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = saveDialog->GetStatus(); + const PSPDialog::DialogStatus status = saveDialog->GetStatus(); hleEatCycles(200); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } static int sceUtilitySavedataUpdate(int animSpeed) { @@ -655,13 +657,13 @@ static int sceUtilityMsgDialogGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = msgDialog->GetStatus(); + const PSPDialog::DialogStatus status = msgDialog->GetStatus(); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } static int sceUtilityMsgDialogAbort() { @@ -708,13 +710,13 @@ static int sceUtilityOskGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = oskDialog->GetStatus(); + const PSPDialog::DialogStatus status = oskDialog->GetStatus(); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } @@ -750,13 +752,13 @@ static int sceUtilityNetconfGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = netDialog->GetStatus(); + const PSPDialog::DialogStatus status = netDialog->GetStatus(); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } /** @@ -1043,13 +1045,13 @@ static int sceUtilityScreenshotGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = screenshotDialog->GetStatus(); + const PSPDialog::DialogStatus status = screenshotDialog->GetStatus(); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogWarning(Log::sceUtility, status); + return hleLogWarning(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } static int sceUtilityScreenshotContStart(u32 paramAddr) { @@ -1096,9 +1098,9 @@ static int sceUtilityGamedataInstallGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = gamedataInstallDialog->GetStatus(); + const PSPDialog::DialogStatus status = gamedataInstallDialog->GetStatus(); CleanupDialogThreads(); - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } static int sceUtilityGamedataInstallAbort() { @@ -1251,13 +1253,13 @@ static int sceUtilityNpSigninGetStatus() { return hleLogDebug(Log::sceUtility, SCE_ERROR_UTILITY_WRONG_TYPE, "wrong dialog type"); } - int status = npSigninDialog->GetStatus(); + const PSPDialog::DialogStatus status = npSigninDialog->GetStatus(); CleanupDialogThreads(); if (oldStatus != status) { oldStatus = status; - return hleLogDebug(Log::sceUtility, status); + return hleLogDebug(Log::sceUtility, status, "status changed: %s", UtilityDialogStatusToString(status)); } - return hleLogVerbose(Log::sceUtility, status); + return hleLogVerbose(Log::sceUtility, status, "status: %s", UtilityDialogStatusToString(status)); } static void sceUtilityInstallInitStart(u32 unknown) {