diff --git a/rpcs3/Emu/Cell/Modules/cellSysutil.h b/rpcs3/Emu/Cell/Modules/cellSysutil.h index 1890d54752..55e8d9762f 100644 --- a/rpcs3/Emu/Cell/Modules/cellSysutil.h +++ b/rpcs3/Emu/Cell/Modules/cellSysutil.h @@ -2,6 +2,8 @@ #include "Emu/Memory/vm_ptr.h" +using CellSysutilUserId = u32; + enum CellSysutilError : u32 { CELL_SYSUTIL_ERROR_TYPE = 0x8002b101, diff --git a/rpcs3/Emu/Cell/Modules/sceNp.cpp b/rpcs3/Emu/Cell/Modules/sceNp.cpp index 1ff47d968c..9508641301 100644 --- a/rpcs3/Emu/Cell/Modules/sceNp.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNp.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" @@ -12,12 +12,377 @@ LOG_CHANNEL(sceNp); +template<> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](auto error) + { + switch (error) + { + STR_CASE(SCE_NP_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_ERROR_ID_NO_SPACE); + STR_CASE(SCE_NP_ERROR_ID_NOT_FOUND); + STR_CASE(SCE_NP_ERROR_SESSION_RUNNING); + STR_CASE(SCE_NP_ERROR_LOGINID_ALREADY_EXISTS); + STR_CASE(SCE_NP_ERROR_INVALID_TICKET_SIZE); + STR_CASE(SCE_NP_ERROR_INVALID_STATE); + STR_CASE(SCE_NP_ERROR_ABORTED); + STR_CASE(SCE_NP_ERROR_OFFLINE); + STR_CASE(SCE_NP_ERROR_VARIANT_ACCOUNT_ID); + STR_CASE(SCE_NP_ERROR_GET_CLOCK); + STR_CASE(SCE_NP_ERROR_INSUFFICIENT_BUFFER); + STR_CASE(SCE_NP_ERROR_EXPIRED_TICKET); + STR_CASE(SCE_NP_ERROR_TICKET_PARAM_NOT_FOUND); + STR_CASE(SCE_NP_ERROR_UNSUPPORTED_TICKET_VERSION); + STR_CASE(SCE_NP_ERROR_TICKET_STATUS_CODE_INVALID); + STR_CASE(SCE_NP_ERROR_INVALID_TICKET_VERSION); + STR_CASE(SCE_NP_ERROR_ALREADY_USED); + STR_CASE(SCE_NP_ERROR_DIFFERENT_USER); + STR_CASE(SCE_NP_ERROR_ALREADY_DONE); + STR_CASE(SCE_NP_BASIC_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_BASIC_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_BASIC_ERROR_NOT_SUPPORTED); + STR_CASE(SCE_NP_BASIC_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_BASIC_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_BASIC_ERROR_BAD_ID); + STR_CASE(SCE_NP_BASIC_ERROR_IDS_DIFFER); + STR_CASE(SCE_NP_BASIC_ERROR_PARSER_FAILED); + STR_CASE(SCE_NP_BASIC_ERROR_TIMEOUT); + STR_CASE(SCE_NP_BASIC_ERROR_NO_EVENT); + STR_CASE(SCE_NP_BASIC_ERROR_EXCEEDS_MAX); + STR_CASE(SCE_NP_BASIC_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_BASIC_ERROR_NOT_REGISTERED); + STR_CASE(SCE_NP_BASIC_ERROR_DATA_LOST); + STR_CASE(SCE_NP_BASIC_ERROR_BUSY); + STR_CASE(SCE_NP_BASIC_ERROR_STATUS); + STR_CASE(SCE_NP_BASIC_ERROR_CANCEL); + STR_CASE(SCE_NP_BASIC_ERROR_INVALID_MEMORY_CONTAINER); + STR_CASE(SCE_NP_BASIC_ERROR_INVALID_DATA_ID); + STR_CASE(SCE_NP_BASIC_ERROR_BROKEN_DATA); + STR_CASE(SCE_NP_BASIC_ERROR_BLOCKLIST_ADD_FAILED); + STR_CASE(SCE_NP_BASIC_ERROR_BLOCKLIST_IS_FULL); + STR_CASE(SCE_NP_BASIC_ERROR_SEND_FAILED); + STR_CASE(SCE_NP_BASIC_ERROR_NOT_CONNECTED); + STR_CASE(SCE_NP_BASIC_ERROR_INSUFFICIENT_DISK_SPACE); + STR_CASE(SCE_NP_BASIC_ERROR_INTERNAL_FAILURE); + STR_CASE(SCE_NP_BASIC_ERROR_DOES_NOT_EXIST); + STR_CASE(SCE_NP_BASIC_ERROR_INVALID); + STR_CASE(SCE_NP_BASIC_ERROR_UNKNOWN); + STR_CASE(SCE_NP_EXT_ERROR_CONTEXT_DOES_NOT_EXIST); + STR_CASE(SCE_NP_EXT_ERROR_CONTEXT_ALREADY_EXISTS); + STR_CASE(SCE_NP_EXT_ERROR_NO_CONTEXT); + STR_CASE(SCE_NP_EXT_ERROR_NO_ORIGIN); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_UTIL_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_UTIL_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_UTIL_ERROR_PARSER_FAILED); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_PROTOCOL_ID); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_NP_ID); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_NP_LOBBY_ID); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_NP_ROOM_ID); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_NP_ENV); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_TITLEID); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_CHARACTER); + STR_CASE(SCE_NP_UTIL_ERROR_INVALID_ESCAPE_STRING); + STR_CASE(SCE_NP_UTIL_ERROR_UNKNOWN_TYPE); + STR_CASE(SCE_NP_UTIL_ERROR_UNKNOWN); + STR_CASE(SCE_NP_UTIL_ERROR_NOT_MATCH); + STR_CASE(SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_INVALID_MEMORY_CONTAINER); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_CANCEL); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_STATUS); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_BUSY); + STR_CASE(SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_PROFILE_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_PROFILE_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_PROFILE_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_PROFILE_ERROR_NOT_SUPPORTED); + STR_CASE(SCE_NP_PROFILE_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_PROFILE_ERROR_CANCEL); + STR_CASE(SCE_NP_PROFILE_ERROR_STATUS); + STR_CASE(SCE_NP_PROFILE_ERROR_BUSY); + STR_CASE(SCE_NP_PROFILE_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_PROFILE_ERROR_ABORT); + STR_CASE(SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_COMMUNITY_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_COMMUNITY_ERROR_NO_TITLE_SET); + STR_CASE(SCE_NP_COMMUNITY_ERROR_NO_LOGIN); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TOO_MANY_OBJECTS); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TRANSACTION_STILL_REFERENCED); + STR_CASE(SCE_NP_COMMUNITY_ERROR_ABORTED); + STR_CASE(SCE_NP_COMMUNITY_ERROR_NO_RESOURCE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_BAD_RESPONSE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_HTTP_SERVER); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_SIGNATURE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TIMEOUT); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT); + STR_CASE(SCE_NP_COMMUNITY_ERROR_UNKNOWN_TYPE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_ID); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_TICKET); + STR_CASE(SCE_NP_COMMUNITY_ERROR_CLIENT_HANDLE_ALREADY_EXISTS); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_BUFFER); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_TYPE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TRANSACTION_ALREADY_END); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TRANSACTION_BEFORE_END); + STR_CASE(SCE_NP_COMMUNITY_ERROR_BUSY_BY_ANOTEHR_TRANSACTION); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_ALIGNMENT); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE); + STR_CASE(SCE_NP_COMMUNITY_ERROR_INVALID_PARTITION); + STR_CASE(SCE_NP_COMMUNITY_ERROR_TOO_MANY_SLOTID); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_BAD_REQUEST); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_TICKET); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SIGNATURE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_EXPIRED_TICKET); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_NPID); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_FORBIDDEN); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INTERNAL_SERVER_ERROR); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_VERSION_NOT_SUPPORTED); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_SERVICE_UNAVAILABLE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_PLAYER_BANNED); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_CENSORED); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_RECORD_FORBIDDEN); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_USER_PROFILE_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_UPLOADER_DATA_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_QUOTA_MASTER_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_TITLE_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_BLACKLISTED_USER_ID); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_GAME_RANKING_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_STORE_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_NOT_BEST_SCORE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_LATEST_UPDATE_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BOARD_MASTER_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_GAME_DATA_MASTER_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ANTICHEAT_DATA); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_TOO_LARGE_DATA); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_USER_NPID); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ENVIRONMENT); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_CHARACTER); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_LENGTH); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_CHARACTER); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_LENGTH); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SCORE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_RANKING_LIMIT); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_FAIL_TO_CREATE_SIGNATURE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MASTER_INFO_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_GAME_DATA_LIMIT); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_SELF_DATA_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_USER_NOT_ASSIGNED); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_GAME_DATA_ALREADY_EXISTS); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_TOO_MANY_RESULTS); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_NOT_RECORDABLE_VERSION); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_TITLE_MASTER_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_VIRTUAL_USER); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_DATA_NOT_FOUND); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_CONDITIONS_NOT_SATISFIED); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_BEFORE_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_END_OF_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_MAINTENANCE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BEFORE_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_END_OF_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MAINTENANCE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_TITLE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_BEFORE_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_END_OF_SERVICE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_MAINTENANCE); + STR_CASE(SCE_NP_COMMUNITY_SERVER_ERROR_UNSPECIFIED); + STR_CASE(SCE_NP_DRM_ERROR_LICENSE_NOT_FOUND); + STR_CASE(SCE_NP_DRM_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_DRM_ERROR_INVALID_PARAM); + STR_CASE(SCE_NP_DRM_ERROR_SERVER_RESPONSE); + STR_CASE(SCE_NP_DRM_ERROR_NO_ENTITLEMENT); + STR_CASE(SCE_NP_DRM_ERROR_BAD_ACT); + STR_CASE(SCE_NP_DRM_ERROR_BAD_FORMAT); + STR_CASE(SCE_NP_DRM_ERROR_NO_LOGIN); + STR_CASE(SCE_NP_DRM_ERROR_INTERNAL); + STR_CASE(SCE_NP_DRM_ERROR_BAD_PERM); + STR_CASE(SCE_NP_DRM_ERROR_UNKNOWN_VERSION); + STR_CASE(SCE_NP_DRM_ERROR_TIME_LIMIT); + STR_CASE(SCE_NP_DRM_ERROR_DIFFERENT_ACCOUNT_ID); + STR_CASE(SCE_NP_DRM_ERROR_DIFFERENT_DRM_TYPE); + STR_CASE(SCE_NP_DRM_ERROR_SERVICE_NOT_STARTED); + STR_CASE(SCE_NP_DRM_ERROR_BUSY); + STR_CASE(SCE_NP_DRM_ERROR_IO); + STR_CASE(SCE_NP_DRM_ERROR_FORMAT); + STR_CASE(SCE_NP_DRM_ERROR_FILENAME); + STR_CASE(SCE_NP_DRM_ERROR_K_LICENSEE); + STR_CASE(SCE_NP_AUTH_EINVAL); + STR_CASE(SCE_NP_AUTH_ENOMEM); + STR_CASE(SCE_NP_AUTH_ESRCH); + STR_CASE(SCE_NP_AUTH_EBUSY); + STR_CASE(SCE_NP_AUTH_EABORT); + STR_CASE(SCE_NP_AUTH_EEXIST); + STR_CASE(SCE_NP_AUTH_EINVALID_ARGUMENT); + STR_CASE(SCE_NP_AUTH_ERROR_SERVICE_END); + STR_CASE(SCE_NP_AUTH_ERROR_SERVICE_DOWN); + STR_CASE(SCE_NP_AUTH_ERROR_SERVICE_BUSY); + STR_CASE(SCE_NP_AUTH_ERROR_SERVER_MAINTENANCE); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_DATA_LENGTH); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_USER_AGENT); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_VERSION); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_SERVICE_ID); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_CREDENTIAL); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_ENTITLEMENT_ID); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_CONSUMED_COUNT); + STR_CASE(SCE_NP_AUTH_ERROR_INVALID_CONSOLE_ID); + STR_CASE(SCE_NP_AUTH_ERROR_CONSOLE_ID_SUSPENDED); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_CLOSED); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_SUSPENDED); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_EULA); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT1); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT2); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT3); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT4); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT5); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT6); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT7); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT8); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT9); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT10); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT11); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT12); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT13); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT14); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT15); + STR_CASE(SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT16); + STR_CASE(SCE_NP_AUTH_ERROR_UNKNOWN); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_PARSER_FAILED); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_INVALID_PROTOCOL_ID); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_INVALID_EXTENSION); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_INVALID_TEXT); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_UNKNOWN_TYPE); + STR_CASE(SCE_NP_CORE_UTIL_ERROR_UNKNOWN); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_INVALID_FORMAT); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_INVALID_HANDLE); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_INVALID_ICON); + STR_CASE(SCE_NP_CORE_PARSER_ERROR_UNKNOWN); + STR_CASE(SCE_NP_CORE_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_CORE_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_CORE_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_CORE_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_CORE_ERROR_ID_NOT_AVAILABLE); + STR_CASE(SCE_NP_CORE_ERROR_USER_OFFLINE); + STR_CASE(SCE_NP_CORE_ERROR_SESSION_RUNNING); + STR_CASE(SCE_NP_CORE_ERROR_SESSION_NOT_ESTABLISHED); + STR_CASE(SCE_NP_CORE_ERROR_SESSION_INVALID_STATE); + STR_CASE(SCE_NP_CORE_ERROR_SESSION_ID_TOO_LONG); + STR_CASE(SCE_NP_CORE_ERROR_SESSION_INVALID_NAMESPACE); + STR_CASE(SCE_NP_CORE_ERROR_CONNECTION_TIMEOUT); + STR_CASE(SCE_NP_CORE_ERROR_GETSOCKOPT); + STR_CASE(SCE_NP_CORE_ERROR_SSL_NOT_INITIALIZED); + STR_CASE(SCE_NP_CORE_ERROR_SSL_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_CORE_ERROR_SSL_NO_CERT); + STR_CASE(SCE_NP_CORE_ERROR_SSL_NO_TRUSTWORTHY_CA); + STR_CASE(SCE_NP_CORE_ERROR_SSL_INVALID_CERT); + STR_CASE(SCE_NP_CORE_ERROR_SSL_CERT_VERIFY); + STR_CASE(SCE_NP_CORE_ERROR_SSL_CN_CHECK); + STR_CASE(SCE_NP_CORE_ERROR_SSL_HANDSHAKE_FAILED); + STR_CASE(SCE_NP_CORE_ERROR_SSL_SEND); + STR_CASE(SCE_NP_CORE_ERROR_SSL_RECV); + STR_CASE(SCE_NP_CORE_ERROR_SSL_CREATE_CTX); + STR_CASE(SCE_NP_CORE_ERROR_PARSE_PEM); + STR_CASE(SCE_NP_CORE_ERROR_INVALID_INITIATE_STREAM); + STR_CASE(SCE_NP_CORE_ERROR_SASL_NOT_SUPPORTED); + STR_CASE(SCE_NP_CORE_ERROR_NAMESPACE_ALREADY_EXISTS); + STR_CASE(SCE_NP_CORE_ERROR_FROM_ALREADY_EXISTS); + STR_CASE(SCE_NP_CORE_ERROR_MODULE_NOT_REGISTERED); + STR_CASE(SCE_NP_CORE_ERROR_MODULE_FROM_NOT_FOUND); + STR_CASE(SCE_NP_CORE_ERROR_UNKNOWN_NAMESPACE); + STR_CASE(SCE_NP_CORE_ERROR_INVALID_VERSION); + STR_CASE(SCE_NP_CORE_ERROR_LOGIN_TIMEOUT); + STR_CASE(SCE_NP_CORE_ERROR_TOO_MANY_SESSIONS); + STR_CASE(SCE_NP_CORE_ERROR_SENDLIST_NOT_FOUND); + STR_CASE(SCE_NP_CORE_ERROR_NO_ID); + STR_CASE(SCE_NP_CORE_ERROR_LOAD_CERTS); + STR_CASE(SCE_NP_CORE_ERROR_NET_SELECT); + STR_CASE(SCE_NP_CORE_ERROR_DISCONNECTED); + STR_CASE(SCE_NP_CORE_ERROR_TICKET_TOO_SMALL); + STR_CASE(SCE_NP_CORE_ERROR_INVALID_TICKET); + STR_CASE(SCE_NP_CORE_ERROR_INVALID_ONLINEID); + STR_CASE(SCE_NP_CORE_ERROR_GETHOSTBYNAME); + STR_CASE(SCE_NP_CORE_ERROR_UNDEFINED_STREAM_ERROR); + STR_CASE(SCE_NP_CORE_ERROR_INTERNAL); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_CONFLICT); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_NOT_AUTHORIZED); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_REMOTE_CONNECTION_FAILED); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_RESOURCE_CONSTRAINT); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_SYSTEM_SHUTDOWN); + STR_CASE(SCE_NP_CORE_SERVER_ERROR_UNSUPPORTED_CLIENT_VERSION); + STR_CASE(SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_SIGNALING_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_SIGNALING_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_SIGNALING_ERROR_CTXID_NOT_AVAILABLE); + STR_CASE(SCE_NP_SIGNALING_ERROR_CTX_NOT_FOUND); + STR_CASE(SCE_NP_SIGNALING_ERROR_REQID_NOT_AVAILABLE); + STR_CASE(SCE_NP_SIGNALING_ERROR_REQ_NOT_FOUND); + STR_CASE(SCE_NP_SIGNALING_ERROR_PARSER_CREATE_FAILED); + STR_CASE(SCE_NP_SIGNALING_ERROR_PARSER_FAILED); + STR_CASE(SCE_NP_SIGNALING_ERROR_INVALID_NAMESPACE); + STR_CASE(SCE_NP_SIGNALING_ERROR_NETINFO_NOT_AVAILABLE); + STR_CASE(SCE_NP_SIGNALING_ERROR_PEER_NOT_RESPONDING); + STR_CASE(SCE_NP_SIGNALING_ERROR_CONNID_NOT_AVAILABLE); + STR_CASE(SCE_NP_SIGNALING_ERROR_CONN_NOT_FOUND); + STR_CASE(SCE_NP_SIGNALING_ERROR_PEER_UNREACHABLE); + STR_CASE(SCE_NP_SIGNALING_ERROR_TERMINATED_BY_PEER); + STR_CASE(SCE_NP_SIGNALING_ERROR_TIMEOUT); + STR_CASE(SCE_NP_SIGNALING_ERROR_CTX_MAX); + STR_CASE(SCE_NP_SIGNALING_ERROR_RESULT_NOT_FOUND); + STR_CASE(SCE_NP_SIGNALING_ERROR_CONN_IN_PROGRESS); + STR_CASE(SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_SIGNALING_ERROR_OWN_NP_ID); + STR_CASE(SCE_NP_SIGNALING_ERROR_TOO_MANY_CONN); + STR_CASE(SCE_NP_SIGNALING_ERROR_TERMINATED_BY_MYSELF); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_NOT_SUPPORTED); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_CANCEL); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_STATUS); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_BUSY); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_ABORT); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_NOT_REGISTERED); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_EXCEEDS_MAX); + STR_CASE(SCE_NP_CUSTOM_MENU_ERROR_INVALID_CHARACTER); + } + + return unknown; + }); +} + s32 g_psn_connection_status = SCE_NP_MANAGER_STATUS_OFFLINE; -s32 sceNpInit(u32 poolsize, vm::ptr poolptr) +error_code sceNpInit(u32 poolsize, vm::ptr poolptr) { sceNp.warning("sceNpInit(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr); + const auto manager = g_fxo->get(); + + if (manager->is_initialized) + { + return SCE_NP_ERROR_ALREADY_INITIALIZED; + } + if (poolsize == 0) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -32,17 +397,28 @@ s32 sceNpInit(u32 poolsize, vm::ptr poolptr) return SCE_NP_ERROR_INVALID_ARGUMENT; } + manager->is_initialized = true; + return CELL_OK; } -s32 sceNpTerm() +error_code sceNpTerm() { sceNp.warning("sceNpTerm()"); + const auto manager = g_fxo->get(); + + if (!manager->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + manager->is_initialized = false; + return CELL_OK; } -s32 npDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) +error_code npDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) { std::array k_licensee{}; @@ -121,21 +497,21 @@ s32 npDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) return CELL_OK; } -s32 sceNpDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) +error_code sceNpDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) { sceNp.warning("sceNpDrmIsAvailable(k_licensee=*0x%x, drm_path=%s)", k_licensee_addr, drm_path); return npDrmIsAvailable(k_licensee_addr, drm_path); } -s32 sceNpDrmIsAvailable2(vm::cptr k_licensee_addr, vm::cptr drm_path) +error_code sceNpDrmIsAvailable2(vm::cptr k_licensee_addr, vm::cptr drm_path) { sceNp.warning("sceNpDrmIsAvailable2(k_licensee=*0x%x, drm_path=%s)", k_licensee_addr, drm_path); return npDrmIsAvailable(k_licensee_addr, drm_path); } -s32 sceNpDrmVerifyUpgradeLicense(vm::cptr content_id) +error_code sceNpDrmVerifyUpgradeLicense(vm::cptr content_id) { sceNp.warning("sceNpDrmVerifyUpgradeLicense(content_id=%s)", content_id); @@ -154,7 +530,7 @@ s32 sceNpDrmVerifyUpgradeLicense(vm::cptr content_id) return CELL_OK; } -s32 sceNpDrmVerifyUpgradeLicense2(vm::cptr content_id) +error_code sceNpDrmVerifyUpgradeLicense2(vm::cptr content_id) { sceNp.warning("sceNpDrmVerifyUpgradeLicense2(content_id=%s)", content_id); @@ -173,22 +549,27 @@ s32 sceNpDrmVerifyUpgradeLicense2(vm::cptr content_id) return CELL_OK; } -s32 sceNpDrmExecuteGamePurchase() +error_code sceNpDrmExecuteGamePurchase() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpDrmExecuteGamePurchase()"); return CELL_OK; } -s32 sceNpDrmGetTimelimit(vm::cptr path, vm::ptr time_remain) +error_code sceNpDrmGetTimelimit(vm::cptr path, vm::ptr time_remain) { - sceNp.warning("sceNpDrmGetTimelimit(path=%s, time_remain=*0x%x)", path, time_remain); + sceNp.todo("sceNpDrmGetTimelimit(path=%s, time_remain=*0x%x)", path, time_remain); + + if (!path || !time_remain) + { + return SCE_NP_ERROR_INVALID_ARGUMENT; + } *time_remain = 0x7FFFFFFFFFFFFFFFULL; return CELL_OK; } -s32 sceNpDrmProcessExitSpawn(ppu_thread& ppu, vm::cptr klicensee, vm::cptr path, vm::cpptr argv, vm::cpptr envp, u32 data, u32 data_size, s32 prio, u64 flags) +error_code sceNpDrmProcessExitSpawn(ppu_thread& ppu, vm::cptr klicensee, vm::cptr path, vm::cpptr argv, vm::cpptr envp, u32 data, u32 data_size, s32 prio, u64 flags) { sceNp.warning("sceNpDrmProcessExitSpawn(klicensee=*0x%x, path=%s, argv=**0x%x, envp=**0x%x, data=*0x%x, data_size=0x%x, prio=%d, flags=0x%x)", klicensee, path, argv, envp, data, data_size, prio, flags); @@ -201,7 +582,7 @@ s32 sceNpDrmProcessExitSpawn(ppu_thread& ppu, vm::cptr klicensee, vm::cptr klicensee, vm::cptr path, vm::cpptr argv, vm::cpptr envp, u32 data, u32 data_size, s32 prio, u64 flags) +error_code sceNpDrmProcessExitSpawn2(ppu_thread& ppu, vm::cptr klicensee, vm::cptr path, vm::cpptr argv, vm::cpptr envp, u32 data, u32 data_size, s32 prio, u64 flags) { sceNp.warning("sceNpDrmProcessExitSpawn2(klicensee=*0x%x, path=%s, argv=**0x%x, envp=**0x%x, data=*0x%x, data_size=0x%x, prio=%d, flags=0x%x)", klicensee, path, argv, envp, data, data_size, prio, flags); @@ -214,99 +595,304 @@ s32 sceNpDrmProcessExitSpawn2(ppu_thread& ppu, vm::cptr klicensee, vm::cptr< return CELL_OK; } -s32 sceNpBasicRegisterHandler() +error_code sceNpBasicRegisterHandler(vm::cptr context, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicRegisterHandler(context=*0x%x, handler=*0x%x, arg=*0x%x)", context, handler, arg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!context || !handler) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicRegisterContextSensitiveHandler() +error_code sceNpBasicRegisterContextSensitiveHandler(vm::cptr context, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicRegisterContextSensitiveHandler(context=*0x%x, handler=*0x%x, arg=*0x%x)", context, handler, arg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!context || !handler) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicUnregisterHandler() +error_code sceNpBasicUnregisterHandler() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicUnregisterHandler()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpBasicSetPresence() +error_code sceNpBasicSetPresence(vm::cptr data, u64 size) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSetPresence(data=*0x%x, size=%d)", data, size); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicSetPresenceDetails() +error_code sceNpBasicSetPresenceDetails(vm::cptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSetPresenceDetails(pres=*0x%x, options=0x%x)", pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!pres || options > SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (pres->size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicSetPresenceDetails2() +error_code sceNpBasicSetPresenceDetails2(vm::cptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSetPresenceDetails2(pres=*0x%x, options=0x%x)", pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!pres || options > SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (pres->size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicSendMessage() +error_code sceNpBasicSendMessage(vm::cptr to, vm::cptr data, u64 size) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSendMessage(to=*0x%x, data=*0x%x, size=%d)", to, data, size); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!to || !to->handle.data || !data || !size) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (size > SCE_NP_BASIC_MAX_MESSAGE_SIZE) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicSendMessageGui() +error_code sceNpBasicSendMessageGui(vm::cptr msg, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSendMessageGui(msg=*0x%x, containerId=%d)", msg, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!msg || msg->count > SCE_NP_BASIC_SEND_MESSAGE_MAX_RECIPIENTS || !msg->npids.handle.data || !(msg->msgFeatures & SCE_NP_BASIC_MESSAGE_FEATURES_ALL_FEATURES)) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (msg->size > SCE_NP_BASIC_MAX_MESSAGE_SIZE) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_BASIC_ERROR_NOT_CONNECTED; + } + return CELL_OK; } -s32 sceNpBasicSendMessageAttachment() +error_code sceNpBasicSendMessageAttachment(vm::cptr to, vm::cptr subject, vm::cptr body, vm::cptr data, u64 size, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicSendMessageAttachment(to=*0x%x, subject=%s, body=%s, data=%s, size=%d, containerId=%d)", to, subject, body, data, size, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!to || !to->handle.data || !data || !size) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (strlen(subject.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX || strlen(body.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_BASIC_ERROR_NOT_CONNECTED; + } + return CELL_OK; } -s32 sceNpBasicRecvMessageAttachment() +error_code sceNpBasicRecvMessageAttachment(sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicRecvMessageAttachment(containerId=%d)", containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpBasicRecvMessageAttachmentLoad() +error_code sceNpBasicRecvMessageAttachmentLoad(u32 id, vm::ptr buffer, vm::ptr size) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicRecvMessageAttachmentLoad(id=%d, buffer=*0x%x, size=*0x%x)", id, buffer, size); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!buffer || !size) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (id > SCE_NP_BASIC_SELECTED_MESSAGE_DATA) + { + return SCE_NP_BASIC_ERROR_INVALID_DATA_ID; + } + return CELL_OK; } -s32 sceNpBasicRecvMessageCustom() +error_code sceNpBasicRecvMessageCustom(u16 mainType, u32 recvOptions, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicRecvMessageCustom(mainType=%d, recvOptions=%d, containerId=%d)", mainType, recvOptions, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!(recvOptions & SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ALL_OPTIONS)) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicMarkMessageAsUsed() +error_code sceNpBasicMarkMessageAsUsed(SceNpBasicMessageId msgId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicMarkMessageAsUsed(msgId=%d)", msgId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + //if (!msgId > ?) + //{ + // return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + //} + return CELL_OK; } -s32 sceNpBasicAbortGui() +error_code sceNpBasicAbortGui() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicAbortGui()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpBasicAddFriend() +error_code sceNpBasicAddFriend(vm::cptr contact, vm::cptr body, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicAddFriend(contact=*0x%x, body=%s, containerId=%d)", contact, body, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!contact || !contact->handle.data) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (strlen(body.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_BASIC_ERROR_NOT_CONNECTED; + } + return CELL_OK; } -s32 sceNpBasicGetFriendListEntryCount(vm::ptr count) +error_code sceNpBasicGetFriendListEntryCount(vm::ptr count) { - sceNp.warning("sceNpBasicGetFriendListEntryCount(count=*0x%x)", count); + sceNp.todo("sceNpBasicGetFriendListEntryCount(count=*0x%x)", count); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } if (!count) { @@ -325,10 +911,21 @@ s32 sceNpBasicGetFriendListEntryCount(vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetFriendListEntry(u32 index, vm::ptr npid) +error_code sceNpBasicGetFriendListEntry(u32 index, vm::ptr npid) { sceNp.todo("sceNpBasicGetFriendListEntry(index=%d, npid=*0x%x)", index, npid); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + // TODO: check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -338,46 +935,131 @@ s32 sceNpBasicGetFriendListEntry(u32 index, vm::ptr npid) return CELL_OK; } -s32 sceNpBasicGetFriendPresenceByIndex() +error_code sceNpBasicGetFriendPresenceByIndex(u32 index, vm::ptr user, vm::ptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicGetFriendPresenceByIndex(index=%d, user=*0x%x, pres=*0x%x, options=%d)", index, user, pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!user || !pres) + { + // TODO: check index and (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicGetFriendPresenceByIndex2() +error_code sceNpBasicGetFriendPresenceByIndex2(u32 index, vm::ptr user, vm::ptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicGetFriendPresenceByIndex2(index=%d, user=*0x%x, pres=*0x%x, options=%d)", index, user, pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!user || !pres) + { + // TODO: check index and (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicGetFriendPresenceByNpId() +error_code sceNpBasicGetFriendPresenceByNpId(vm::cptr npid, vm::ptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicGetFriendPresenceByNpId(npid=*0x%x, pres=*0x%x, options=%d)", npid, pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid || !pres) + { + // TODO: check (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicGetFriendPresenceByNpId2() +error_code sceNpBasicGetFriendPresenceByNpId2(vm::cptr npid, vm::ptr pres, u32 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicGetFriendPresenceByNpId2(npid=*0x%x, pres=*0x%x, options=%d)", npid, pres, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid || !pres) + { + // TODO: check (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicAddPlayersHistory() +error_code sceNpBasicAddPlayersHistory(vm::cptr npid, vm::ptr description) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicAddPlayersHistory(npid=*0x%x, description=*0x%x)", npid, description); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid || !npid->handle.data) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (strlen(description.get_ptr()) > SCE_NP_BASIC_DESCRIPTION_CHARACTER_MAX) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicAddPlayersHistoryAsync() +error_code sceNpBasicAddPlayersHistoryAsync(vm::cptr npids, u64 count, vm::ptr description, vm::ptr reqId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpBasicAddPlayersHistoryAsync(npids=*0x%x, count=%d, description=*0x%x, reqId=*0x%x)", npids, count, description, reqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npids || !npids->handle.data) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + + if (count > SCE_NP_BASIC_PLAYER_HISTORY_MAX_PLAYERS || strlen(description.get_ptr()) > SCE_NP_BASIC_DESCRIPTION_CHARACTER_MAX) + { + return SCE_NP_BASIC_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpBasicGetPlayersHistoryEntryCount(u32 options, vm::ptr count) +error_code sceNpBasicGetPlayersHistoryEntryCount(u32 options, vm::ptr count) { sceNp.todo("sceNpBasicGetPlayersHistoryEntryCount(options=%d, count=*0x%x)", options, count); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + if (!count) { return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; @@ -395,10 +1077,21 @@ s32 sceNpBasicGetPlayersHistoryEntryCount(u32 options, vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetPlayersHistoryEntry(u32 options, u32 index, vm::ptr npid) +error_code sceNpBasicGetPlayersHistoryEntry(u32 options, u32 index, vm::ptr npid) { sceNp.todo("sceNpBasicGetPlayersHistoryEntry(options=%d, index=%d, npid=*0x%x)", options, index, npid); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + // TODO: Check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -408,17 +1101,32 @@ s32 sceNpBasicGetPlayersHistoryEntry(u32 options, u32 index, vm::ptr np return CELL_OK; } -s32 sceNpBasicAddBlockListEntry(vm::cptr npid) +error_code sceNpBasicAddBlockListEntry(vm::cptr npid) { sceNp.todo("sceNpBasicAddBlockListEntry(npid=*0x%x)", npid); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid || !npid->handle.data) + { + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpBasicGetBlockListEntryCount(vm::ptr count) +error_code sceNpBasicGetBlockListEntryCount(vm::ptr count) { sceNp.todo("sceNpBasicGetBlockListEntryCount(count=*0x%x)", count); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + if (!count) { return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; @@ -436,10 +1144,21 @@ s32 sceNpBasicGetBlockListEntryCount(vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetBlockListEntry(u32 index, vm::ptr npid) +error_code sceNpBasicGetBlockListEntry(u32 index, vm::ptr npid) { sceNp.todo("sceNpBasicGetBlockListEntry(index=%d, npid=*0x%x)", index, npid); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + // TODO: check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -449,10 +1168,15 @@ s32 sceNpBasicGetBlockListEntry(u32 index, vm::ptr npid) return CELL_OK; } -s32 sceNpBasicGetMessageAttachmentEntryCount(vm::ptr count) +error_code sceNpBasicGetMessageAttachmentEntryCount(vm::ptr count) { sceNp.todo("sceNpBasicGetMessageAttachmentEntryCount(count=*0x%x)", count); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + if (!count) { return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; @@ -470,25 +1194,18 @@ s32 sceNpBasicGetMessageAttachmentEntryCount(vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetMessageAttachmentEntry(u32 index, vm::ptr from) +error_code sceNpBasicGetMessageAttachmentEntry(u32 index, vm::ptr from) { sceNp.todo("sceNpBasicGetMessageAttachmentEntry(index=%d, from=*0x%x)", index, from); - // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND - if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + if (!g_fxo->get()->is_initialized) { - return SCE_NP_ERROR_ID_NOT_FOUND; + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; } - return CELL_OK; -} - -s32 sceNpBasicGetCustomInvitationEntryCount(vm::ptr count) -{ - sceNp.todo("sceNpBasicGetCustomInvitationEntryCount(count=*0x%x)", count); - - if (!count) + if (!from) { + // TODO: check index return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; } @@ -498,29 +1215,58 @@ s32 sceNpBasicGetCustomInvitationEntryCount(vm::ptr count) return SCE_NP_ERROR_ID_NOT_FOUND; } + return CELL_OK; +} + +error_code sceNpBasicGetCustomInvitationEntryCount(vm::ptr count) +{ + sceNp.todo("sceNpBasicGetCustomInvitationEntryCount(count=*0x%x)", count); + + if (!count) + { + return SCE_NP_AUTH_EINVAL; + } + + // TODO: Find the correct test which returns SCE_NP_AUTH_ESRCH + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_AUTH_ESRCH; + } + // TODO: Check if there are custom invitations *count = 0; return CELL_OK; } -s32 sceNpBasicGetCustomInvitationEntry(u32 index, vm::ptr from) +error_code sceNpBasicGetCustomInvitationEntry(u32 index, vm::ptr from) { sceNp.todo("sceNpBasicGetCustomInvitationEntry(index=%d, from=*0x%x)", index, from); + if (!from) + { + // TODO: check index + return SCE_NP_AUTH_EINVAL; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { - return SCE_NP_ERROR_ID_NOT_FOUND; + return SCE_NP_AUTH_ESRCH; } return CELL_OK; } -s32 sceNpBasicGetMatchingInvitationEntryCount(vm::ptr count) +error_code sceNpBasicGetMatchingInvitationEntryCount(vm::ptr count) { sceNp.todo("sceNpBasicGetMatchingInvitationEntryCount(count=*0x%x)", count); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + if (!count) { return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; @@ -538,10 +1284,21 @@ s32 sceNpBasicGetMatchingInvitationEntryCount(vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetMatchingInvitationEntry(u32 index, vm::ptr from) +error_code sceNpBasicGetMatchingInvitationEntry(u32 index, vm::ptr from) { sceNp.todo("sceNpBasicGetMatchingInvitationEntry(index=%d, from=*0x%x)", index, from); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!from) + { + // TODO: check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -551,10 +1308,15 @@ s32 sceNpBasicGetMatchingInvitationEntry(u32 index, vm::ptr from) return CELL_OK; } -s32 sceNpBasicGetClanMessageEntryCount(vm::ptr count) +error_code sceNpBasicGetClanMessageEntryCount(vm::ptr count) { sceNp.todo("sceNpBasicGetClanMessageEntryCount(count=*0x%x)", count); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + if (!count) { return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; @@ -572,10 +1334,21 @@ s32 sceNpBasicGetClanMessageEntryCount(vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetClanMessageEntry(u32 index, vm::ptr from) +error_code sceNpBasicGetClanMessageEntry(u32 index, vm::ptr from) { sceNp.todo("sceNpBasicGetClanMessageEntry(index=%d, from=*0x%x)", index, from); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!from) + { + // TODO: check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -585,9 +1358,14 @@ s32 sceNpBasicGetClanMessageEntry(u32 index, vm::ptr from) return CELL_OK; } -s32 sceNpBasicGetMessageEntryCount(u32 type, vm::ptr count) +error_code sceNpBasicGetMessageEntryCount(u32 type, vm::ptr count) { - sceNp.warning("sceNpBasicGetMessageEntryCount(type=%d, count=*0x%x)", type, count); + sceNp.todo("sceNpBasicGetMessageEntryCount(type=%d, count=*0x%x)", type, count); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } if (!count) { @@ -606,10 +1384,21 @@ s32 sceNpBasicGetMessageEntryCount(u32 type, vm::ptr count) return CELL_OK; } -s32 sceNpBasicGetMessageEntry(u32 type, u32 index, vm::ptr from) +error_code sceNpBasicGetMessageEntry(u32 type, u32 index, vm::ptr from) { sceNp.todo("sceNpBasicGetMessageEntry(type=%d, index=%d, from=*0x%x)", type, index, from); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_BASIC_ERROR_NOT_INITIALIZED; + } + + if (!from) + { + // TODO: check index + return SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; + } + // TODO: Find the correct test which returns SCE_NP_ERROR_ID_NOT_FOUND if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { @@ -619,9 +1408,9 @@ s32 sceNpBasicGetMessageEntry(u32 type, u32 index, vm::ptr from) return CELL_OK; } -s32 sceNpBasicGetEvent(vm::ptr event, vm::ptr from, vm::ptr data, vm::ptr size) +error_code sceNpBasicGetEvent(vm::ptr event, vm::ptr from, vm::ptr data, vm::ptr size) { - sceNp.warning("sceNpBasicGetEvent(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size); + sceNp.todo("sceNpBasicGetEvent(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size); // TODO: Check for other error and pass other events //*event = SCE_NP_BASIC_EVENT_OFFLINE; // This event only indicates a contact is offline, not the current status of the connection @@ -629,396 +1418,781 @@ s32 sceNpBasicGetEvent(vm::ptr event, vm::ptr from, vm::ptr< return SCE_NP_BASIC_ERROR_NO_EVENT; } -s32 sceNpCommerceCreateCtx() +error_code sceNpCommerceCreateCtx(u32 version, vm::ptr npId, vm::ptr handler, vm::ptr arg, vm::ptr ctx_id) +{ + sceNp.todo("sceNpCommerceCreateCtx(version=%d, event=*0x%x, from=*0x%x, arg=*0x%x, ctx_id=*0x%x)", version, npId, handler, arg, ctx_id); + return CELL_OK; +} + +error_code sceNpCommerceDestroyCtx(u32 ctx_id) +{ + sceNp.todo("sceNpCommerceDestroyCtx(ctx_id=%d)", ctx_id); + return CELL_OK; +} + +error_code sceNpCommerceInitProductCategory(vm::ptr pc, vm::cptr data, u64 data_size) +{ + sceNp.todo("sceNpCommerceInitProductCategory(pc=*0x%x, data=*0x%x, data_size=%d)", pc, data, data_size); + return CELL_OK; +} + +void sceNpCommerceDestroyProductCategory(vm::ptr pc) +{ + sceNp.todo("sceNpCommerceDestroyProductCategory(pc=*0x%x)", pc); +} + +error_code sceNpCommerceGetProductCategoryStart(u32 ctx_id, vm::cptr category_id, s32 lang_code, vm::ptr req_id) +{ + sceNp.todo("sceNpCommerceGetProductCategoryStart(ctx_id=%d, category_id=%s, lang_code=%d, req_id=*0x%x)", ctx_id, category_id, lang_code, req_id); + return CELL_OK; +} + +error_code sceNpCommerceGetProductCategoryFinish(u32 req_id) +{ + sceNp.todo("sceNpCommerceGetProductCategoryFinish(req_id=%d)", req_id); + return CELL_OK; +} + +error_code sceNpCommerceGetProductCategoryResult(u32 req_id, vm::ptr buf, u64 buf_size, vm::ptr fill_size) +{ + sceNp.todo("sceNpCommerceGetProductCategoryResult(req_id=%d, buf=*0x%x, buf_size=%d, fill_size=*0x%x)", req_id, buf, buf_size, fill_size); + return CELL_OK; +} + +error_code sceNpCommerceGetProductCategoryAbort(u32 req_id) +{ + sceNp.todo("sceNpCommerceGetProductCategoryAbort(req_id=%d)", req_id); + return CELL_OK; +} + +vm::cptr sceNpCommerceGetProductId(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetProductId(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetProductName(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetProductName(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetCategoryDescription(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCategoryDescription(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetCategoryId(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCategoryId(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetCategoryImageURL(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCategoryImageURL(info=*0x%x)", info); + return vm::null; +} + +error_code sceNpCommerceGetCategoryInfo(vm::ptr pc, vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCategoryInfo(pc=*0x%x, info=*0x%x)", pc, info); + return CELL_OK; +} + +vm::cptr sceNpCommerceGetCategoryName(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCategoryName(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetCurrencyCode(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCurrencyCode(info=*0x%x)", info); + return vm::null; +} + +u32 sceNpCommerceGetCurrencyDecimals(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCurrencyDecimals(info=*0x%x)", info); + return 0; +} + +error_code sceNpCommerceGetCurrencyInfo(vm::ptr pc, vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetCurrencyInfo(pc=*0x%x, info=*0x%x)", pc, info); + return CELL_OK; +} + +error_code sceNpCommerceGetNumOfChildCategory(vm::ptr pc, vm::ptr num) +{ + sceNp.todo("sceNpCommerceGetNumOfChildCategory(pc=*0x%x, num=*0x%x)", pc, num); + return CELL_OK; +} + +error_code sceNpCommerceGetNumOfChildProductSku(vm::ptr pc, vm::ptr num) +{ + sceNp.todo("sceNpCommerceGetNumOfChildProductSku(pc=*0x%x, num=*0x%x)", pc, num); + return CELL_OK; +} + +vm::cptr sceNpCommerceGetSkuDescription(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetSkuDescription(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetSkuId(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetSkuId(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetSkuImageURL(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetSkuImageURL(info=*0x%x)", info); + return vm::null; +} + +vm::cptr sceNpCommerceGetSkuName(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetSkuName(info=*0x%x)", info); + return vm::null; +} + +void sceNpCommerceGetSkuPrice(vm::ptr info, vm::ptr price) +{ + sceNp.todo("sceNpCommerceGetSkuPrice(info=*0x%x, price=*0x%x)", info, price); +} + +vm::cptr sceNpCommerceGetSkuUserData(vm::ptr info) +{ + sceNp.todo("sceNpCommerceGetSkuUserData(info=*0x%x)", info); + return vm::null; +} + +error_code sceNpCommerceSetDataFlagStart() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceDestroyCtx() +error_code sceNpCommerceGetDataFlagStart() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceInitProductCategory() +error_code sceNpCommerceSetDataFlagFinish() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceDestroyProductCategory() +error_code sceNpCommerceGetDataFlagFinish() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceGetProductCategoryStart() +error_code sceNpCommerceGetDataFlagState() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceGetProductCategoryFinish() +error_code sceNpCommerceGetDataFlagAbort() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpCommerceGetProductCategoryResult() +error_code sceNpCommerceGetChildCategoryInfo(vm::ptr pc, u32 child_index, vm::ptr info) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpCommerceGetChildCategoryInfo(pc=*0x%x, child_index=%d, info=*0x%x)", pc, child_index, info); return CELL_OK; } -s32 sceNpCommerceGetProductCategoryAbort() +error_code sceNpCommerceGetChildProductSkuInfo(vm::ptr pc, u32 child_index, vm::ptr info) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpCommerceGetChildProductSkuInfo(pc=*0x%x, child_index=%d, info=*0x%x)", pc, child_index, info); return CELL_OK; } -s32 sceNpCommerceGetProductId() +error_code sceNpCommerceDoCheckoutStartAsync(u32 ctx_id, vm::cpptr sku_ids, u32 sku_num, sys_memory_container_t container, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpCommerceDoCheckoutStartAsync(ctx_id=%d, sku_ids=*0x%x, sku_num=%d, container=%d, req_id=*0x%x)", ctx_id, sku_ids, sku_num, container, req_id); return CELL_OK; } -s32 sceNpCommerceGetProductName() +error_code sceNpCommerceDoCheckoutFinishAsync(u32 req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpCommerceDoCheckoutFinishAsync(req_id=%d)", req_id); return CELL_OK; } -s32 sceNpCommerceGetCategoryDescription() +error_code sceNpCustomMenuRegisterActions(vm::cptr menu, vm::ptr handler, vm::ptr userArg, u64 options) { - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} + sceNp.todo("sceNpCustomMenuRegisterActions(menu=*0x%x, handler=*0x%x, userArg=*0x%x, options=0x%x)", menu, handler, userArg, options); -s32 sceNpCommerceGetCategoryId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } -s32 sceNpCommerceGetCategoryImageURL() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetCategoryInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetCategoryName() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetCurrencyCode() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetCurrencyDecimals() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetCurrencyInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetNumOfChildCategory() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetNumOfChildProductSku() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuDescription() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuImageURL() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuName() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuPrice() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetSkuUserData() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceSetDataFlagStart() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetDataFlagStart() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceSetDataFlagFinish() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetDataFlagFinish() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetDataFlagState() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetDataFlagAbort() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetChildCategoryInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceGetChildProductSkuInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceDoCheckoutStartAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCommerceDoCheckoutFinishAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCustomMenuRegisterActions() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCustomMenuActionSetActivation() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpCustomMenuRegisterExceptionList() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpFriendlist() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpFriendlistCustom() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpFriendlistAbortGui() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpLookupInit() -{ - sceNp.warning("sceNpLookupInit()"); + if (!menu || !handler) + { + return SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; + } return CELL_OK; } -s32 sceNpLookupTerm() +error_code sceNpCustomMenuActionSetActivation(vm::cptr array, u64 options) { - sceNp.warning("sceNpLookupTerm()"); + sceNp.todo("sceNpCustomMenuActionSetActivation(array=*0x%x, options=0x%x)", array, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } + + if (!array) + { + return SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; + } return CELL_OK; } -s32 sceNpLookupCreateTitleCtx() +error_code sceNpCustomMenuRegisterExceptionList(vm::cptr items, u32 numItems, u64 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpCustomMenuRegisterExceptionList(items=*0x%x, numItems=%d, options=0x%x)", items, numItems, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } + + if (!items) + { + return SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; + } + + if (numItems > SCE_NP_CUSTOM_MENU_ACTION_ITEMS_MAX) + { + // TODO: what about SCE_NP_CUSTOM_MENU_ACTION_ITEMS_TOTAL_MAX + return SCE_NP_CUSTOM_MENU_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpLookupDestroyTitleCtx() +error_code sceNpFriendlist(vm::ptr resultHandler, vm::ptr userArg, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpFriendlist(resultHandler=*0x%x, userArg=*0x%x, containerId=%d)", resultHandler, userArg, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } + + if (!resultHandler) + { + return SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpLookupCreateTransactionCtx() +error_code sceNpFriendlistCustom(SceNpFriendlistCustomOptions options, vm::ptr resultHandler, vm::ptr userArg, sys_memory_container_t containerId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpFriendlistCustom(options=0x%x, resultHandler=*0x%x, userArg=*0x%x, containerId=%d)", options, resultHandler, userArg, containerId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } + + if (!resultHandler) + { + return SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpLookupDestroyTransactionCtx() +error_code sceNpFriendlistAbortGui() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpFriendlistAbortGui()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupSetTimeout() +error_code sceNpLookupInit() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupInit()"); + + const auto lookup_manager = g_fxo->get(); + + // TODO: check if this might throw SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED + lookup_manager->is_initialized = true; + return CELL_OK; } -s32 sceNpLookupAbortTransaction() +error_code sceNpLookupTerm() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupTerm()"); + + const auto lookup_manager = g_fxo->get(); + + // TODO: check if this might throw SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED + lookup_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpLookupWaitAsync() +error_code sceNpLookupCreateTitleCtx(vm::cptr communicationId, vm::cptr selfNpId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupCreateTitleCtx(communicationId=*0x%x, selfNpId=0x%x)", communicationId, selfNpId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!communicationId || !selfNpId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + return CELL_OK; } -s32 sceNpLookupPollAsync() +error_code sceNpLookupDestroyTitleCtx(vm::cptr communicationId, vm::cptr selfNpId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupDestroyTitleCtx(communicationId=*0x%x, selfNpId=0x%x)", communicationId, selfNpId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!communicationId || !selfNpId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + return CELL_OK; } -s32 sceNpLookupNpId() +error_code sceNpLookupCreateTransactionCtx(s32 titleCtxId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupCreateTransactionCtx(titleCtxId=%d)", titleCtxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpLookupNpIdAsync() +error_code sceNpLookupDestroyTransactionCtx(s32 transId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupDestroyTransactionCtx(transId=%d)", transId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupUserProfile() +error_code sceNpLookupSetTimeout(s32 ctxId, usecond_t timeout) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupSetTimeout(ctxId=%d, timeout=%d)", ctxId, timeout); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (timeout > 10000000) // 10 seconds + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpLookupUserProfileAsync() +error_code sceNpLookupAbortTransaction(s32 transId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupAbortTransaction(transId=%d)", transId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupUserProfileWithAvatarSize() +error_code sceNpLookupWaitAsync(s32 transId, vm::ptr result) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupWaitAsync(transId=%d, result=%d)", transId, result); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupUserProfileWithAvatarSizeAsync() +error_code sceNpLookupPollAsync(s32 transId, vm::ptr result) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupPollAsync(transId=%d, result=%d)", transId, result); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupAvatarImage() +error_code sceNpLookupNpId(s32 transId, vm::cptr onlineId, vm::ptr npId, vm::ptr option) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupNpId(transId=%d, onlineId=*0x%x, npId=*0x%x, option=*0x%x)", transId, onlineId, npId, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!onlineId || !npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpLookupAvatarImageAsync() +error_code sceNpLookupNpIdAsync(s32 transId, vm::ptr onlineId, vm::ptr npId, s32 prio, vm::ptr option) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupNpIdAsync(transId=%d, onlineId=*0x%x, npId=*0x%x, prio=%d, option=*0x%x)", transId, onlineId, npId, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!onlineId || !npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpLookupTitleStorage() +error_code sceNpLookupUserProfile(s32 transId, vm::cptr npId, vm::ptr userInfo, vm::ptr aboutMe, vm::ptr languages, vm::ptr countryCode, vm::ptr avatarImage, vm::ptr option) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupUserProfile(transId=%d, npId=*0x%x, userInfo=*0x%x, aboutMe=*0x%x, languages=*0x%x, countryCode=*0x%x, avatarImage=*0x%x, option=*0x%x)", transId, npId, userInfo, aboutMe, languages, countryCode, avatarImage, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpLookupTitleStorageAsync() +error_code sceNpLookupUserProfileAsync(s32 transId, vm::cptr npId, vm::ptr userInfo, vm::ptr aboutMe, + vm::ptr languages, vm::ptr countryCode, vm::ptr avatarImage, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpLookupUserProfile(transId=%d, npId=*0x%x, userInfo=*0x%x, aboutMe=*0x%x, languages=*0x%x, countryCode=*0x%x, avatarImage=*0x%x, prio=%d, option=*0x%x)", + transId, npId, userInfo, aboutMe, languages, countryCode, avatarImage, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpLookupUserProfileWithAvatarSize(s32 transId, s32 avatarSizeType, vm::cptr npId, vm::ptr userInfo, vm::ptr aboutMe, + vm::ptr languages, vm::ptr countryCode, vm::ptr avatarImageData, u64 avatarImageDataMaxSize, vm::ptr avatarImageDataSize, vm::ptr option) +{ + sceNp.todo("sceNpLookupUserProfileWithAvatarSize(transId=%d, avatarSizeType=%d, npId=*0x%x, userInfo=*0x%x, aboutMe=*0x%x, languages=*0x%x, countryCode=*0x%x, avatarImageData=*0x%x, avatarImageDataMaxSize=%d, avatarImageDataSize=*0x%x, option=*0x%x)", + transId, avatarSizeType, npId, userInfo, aboutMe, languages, countryCode, avatarImageData, avatarImageDataMaxSize, avatarImageDataSize, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpLookupUserProfileWithAvatarSizeAsync(s32 transId, s32 avatarSizeType, vm::cptr npId, vm::ptr userInfo, vm::ptr aboutMe, + vm::ptr languages, vm::ptr countryCode, vm::ptr avatarImageData, u64 avatarImageDataMaxSize, vm::ptr avatarImageDataSize, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpLookupUserProfileWithAvatarSizeAsync(transId=%d, avatarSizeType=%d, npId=*0x%x, userInfo=*0x%x, aboutMe=*0x%x, languages=*0x%x, countryCode=*0x%x, avatarImageData=*0x%x, avatarImageDataMaxSize=%d, avatarImageDataSize=*0x%x, prio=%d, option=*0x%x)", + transId, avatarSizeType, npId, userInfo, aboutMe, languages, countryCode, avatarImageData, avatarImageDataMaxSize, avatarImageDataSize, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpLookupAvatarImage(s32 transId, vm::ptr avatarUrl, vm::ptr avatarImage, vm::ptr option) +{ + sceNp.todo("sceNpLookupAvatarImage(transId=%d, avatarUrl=*0x%x, avatarImage=*0x%x, option=*0x%x)", transId, avatarUrl, avatarImage, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!avatarUrl || !avatarImage) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpLookupAvatarImageAsync(s32 transId, vm::ptr avatarUrl, vm::ptr avatarImage, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpLookupAvatarImageAsync(transId=%d, avatarUrl=*0x%x, avatarImage=*0x%x, prio=%d, option=*0x%x)", transId, avatarUrl, avatarImage, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!avatarUrl || !avatarImage) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpLookupTitleStorage() { UNIMPLEMENTED_FUNC(sceNp); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupTitleSmallStorage() +error_code sceNpLookupTitleStorageAsync() { UNIMPLEMENTED_FUNC(sceNp); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpLookupTitleSmallStorageAsync() +error_code sceNpLookupTitleSmallStorage(s32 transId, vm::ptr data, u64 maxSize, vm::ptr contentLength, vm::ptr option) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpLookupTitleSmallStorage(transId=%d, data=*0x%x, maxSize=%d, contentLength=*0x%x, option=*0x%x)", transId, data, maxSize, contentLength, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!data) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + //if (something > maxSize) + //{ + // return SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE; + //} + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpManagerRegisterCallback(vm::ptr callback, vm::ptr arg) +error_code sceNpLookupTitleSmallStorageAsync(s32 transId, vm::ptr data, u64 maxSize, vm::ptr contentLength, s32 prio, vm::ptr option) { - sceNp.warning("sceNpManagerRegisterCallback(callback=*0x%x, arg=*0x%x)", callback, arg); + sceNp.todo("sceNpLookupTitleSmallStorageAsync(transId=%d, data=*0x%x, maxSize=%d, contentLength=*0x%x, prio=%d, option=*0x%x)", transId, data, maxSize, contentLength, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!data) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + //if (something > maxSize) + //{ + // return SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE; + //} + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpManagerRegisterCallback(vm::ptr callback, vm::ptr arg) +{ + sceNp.todo("sceNpManagerRegisterCallback(callback=*0x%x, arg=*0x%x)", callback, arg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } if (!callback) { @@ -1028,16 +2202,26 @@ s32 sceNpManagerRegisterCallback(vm::ptr callback, vm::ptr return CELL_OK; } -s32 sceNpManagerUnregisterCallback() +error_code sceNpManagerUnregisterCallback() { sceNp.todo("sceNpManagerUnregisterCallback()"); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpManagerGetStatus(vm::ptr status) +error_code sceNpManagerGetStatus(vm::ptr status) { - sceNp.warning("sceNpManagerGetStatus(status=*0x%x)", status); + sceNp.todo("sceNpManagerGetStatus(status=*0x%x)", status); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } if (!status) { @@ -1049,10 +2233,15 @@ s32 sceNpManagerGetStatus(vm::ptr status) return CELL_OK; } -s32 sceNpManagerGetNetworkTime(vm::ptr pTick) +error_code sceNpManagerGetNetworkTime(vm::ptr pTick) { sceNp.warning("sceNpManagerGetNetworkTime(pTick=*0x%x)", pTick); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!pTick) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1075,10 +2264,15 @@ s32 sceNpManagerGetNetworkTime(vm::ptr pTick) return CELL_OK; } -s32 sceNpManagerGetOnlineId(vm::ptr onlineId) +error_code sceNpManagerGetOnlineId(vm::ptr onlineId) { sceNp.todo("sceNpManagerGetOnlineId(onlineId=*0x%x)", onlineId); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!onlineId) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1097,10 +2291,15 @@ s32 sceNpManagerGetOnlineId(vm::ptr onlineId) return CELL_OK; } -s32 sceNpManagerGetNpId(ppu_thread& ppu, vm::ptr npId) +error_code sceNpManagerGetNpId(ppu_thread& ppu, vm::ptr npId) { sceNp.todo("sceNpManagerGetNpId(npId=*0x%x)", npId); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!npId) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1119,10 +2318,15 @@ s32 sceNpManagerGetNpId(ppu_thread& ppu, vm::ptr npId) return CELL_OK; } -s32 sceNpManagerGetOnlineName(vm::ptr onlineName) +error_code sceNpManagerGetOnlineName(vm::ptr onlineName) { sceNp.todo("sceNpManagerGetOnlineName(onlineName=*0x%x)", onlineName); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!onlineName) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1141,10 +2345,15 @@ s32 sceNpManagerGetOnlineName(vm::ptr onlineName) return CELL_OK; } -s32 sceNpManagerGetAvatarUrl(vm::ptr avatarUrl) +error_code sceNpManagerGetAvatarUrl(vm::ptr avatarUrl) { sceNp.todo("sceNpManagerGetAvatarUrl(avatarUrl=*0x%x)", avatarUrl); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!avatarUrl) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1163,10 +2372,15 @@ s32 sceNpManagerGetAvatarUrl(vm::ptr avatarUrl) return CELL_OK; } -s32 sceNpManagerGetMyLanguages(vm::ptr myLanguages) +error_code sceNpManagerGetMyLanguages(vm::ptr myLanguages) { sceNp.todo("sceNpManagerGetMyLanguages(myLanguages=*0x%x)", myLanguages); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!myLanguages) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1185,10 +2399,15 @@ s32 sceNpManagerGetMyLanguages(vm::ptr myLanguages) return CELL_OK; } -s32 sceNpManagerGetAccountRegion(vm::ptr countryCode, vm::ptr language) +error_code sceNpManagerGetAccountRegion(vm::ptr countryCode, vm::ptr language) { sceNp.todo("sceNpManagerGetAccountRegion(countryCode=*0x%x, language=*0x%x)", countryCode, language); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!countryCode || !language) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1207,10 +2426,15 @@ s32 sceNpManagerGetAccountRegion(vm::ptr countryCode, vm::ptr< return CELL_OK; } -s32 sceNpManagerGetAccountAge(vm::ptr age) +error_code sceNpManagerGetAccountAge(vm::ptr age) { sceNp.todo("sceNpManagerGetAccountAge(age=*0x%x)", age); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!age) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1229,9 +2453,14 @@ s32 sceNpManagerGetAccountAge(vm::ptr age) return CELL_OK; } -s32 sceNpManagerGetContentRatingFlag(vm::ptr isRestricted, vm::ptr age) +error_code sceNpManagerGetContentRatingFlag(vm::ptr isRestricted, vm::ptr age) { - sceNp.warning("sceNpManagerGetContentRatingFlag(isRestricted=*0x%x, age=*0x%x)", isRestricted, age); + sceNp.todo("sceNpManagerGetContentRatingFlag(isRestricted=*0x%x, age=*0x%x)", isRestricted, age); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } if (!isRestricted || !age) { @@ -1255,10 +2484,15 @@ s32 sceNpManagerGetContentRatingFlag(vm::ptr isRestricted, vm::ptr age return CELL_OK; } -s32 sceNpManagerGetChatRestrictionFlag(vm::ptr isRestricted) +error_code sceNpManagerGetChatRestrictionFlag(vm::ptr isRestricted) { sceNp.todo("sceNpManagerGetChatRestrictionFlag(isRestricted=*0x%x)", isRestricted); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + if (!isRestricted) { return SCE_NP_ERROR_INVALID_ARGUMENT; @@ -1280,282 +2514,509 @@ s32 sceNpManagerGetChatRestrictionFlag(vm::ptr isRestricted) return CELL_OK; } -s32 sceNpManagerGetCachedInfo() +error_code sceNpManagerGetCachedInfo(CellSysutilUserId userId, vm::ptr param) +{ + sceNp.todo("sceNpManagerGetChatRestrictionFlag(userId=%d, param=*0x%x)", userId, param); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!param) + { + return SCE_NP_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpManagerGetPsHandle() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpManagerGetPsHandle() +error_code sceNpManagerRequestTicket(vm::cptr npId, vm::cptr serviceId, vm::cptr cookie, u64 cookieSize, vm::cptr entitlementId, u32 consumedCount) { - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} + sceNp.todo("sceNpManagerRequestTicket(npId=*0x%x, serviceId=%s, cookie=*0x%x, cookieSize=%d, entitlementId=%s, consumedCount=%d)", + npId, serviceId, cookie, cookieSize, entitlementId, consumedCount); -s32 sceNpManagerRequestTicket() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } -s32 sceNpManagerRequestTicket2() -{ - UNIMPLEMENTED_FUNC(sceNp); + if (!serviceId || !cookie || cookieSize > SCE_NP_COOKIE_MAX_SIZE || !entitlementId) + { + return SCE_NP_AUTH_EINVALID_ARGUMENT; + } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { return SCE_NP_ERROR_OFFLINE; } + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_ERROR_INVALID_STATE; + } + return CELL_OK; } -s32 sceNpManagerGetTicket() +error_code sceNpManagerRequestTicket2(vm::cptr npId, vm::cptr version, vm::cptr serviceId, + vm::cptr cookie, u64 cookieSize, vm::cptr entitlementId, u32 consumedCount) +{ + sceNp.todo("sceNpManagerRequestTicket2(npId=*0x%x, version=*0x%x, serviceId=%s, cookie=*0x%x, cookieSize=%d, entitlementId=%s, consumedCount=%d)", + npId, version, serviceId, cookie, cookieSize, entitlementId, consumedCount); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!serviceId || !cookie || cookieSize > SCE_NP_COOKIE_MAX_SIZE || !entitlementId) + { + return SCE_NP_AUTH_EINVALID_ARGUMENT; + } + + if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) + { + return SCE_NP_ERROR_OFFLINE; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_ERROR_INVALID_STATE; + } + + return CELL_OK; +} + +error_code sceNpManagerGetTicket(vm::ptr buffer, vm::ptr bufferSize) +{ + sceNp.todo("sceNpManagerGetTicket(buffer=*0x%x, bufferSize=*0x%x)", buffer, bufferSize); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!bufferSize) + { + return SCE_NP_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpManagerGetTicketParam(s32 paramId, vm::ptr param) +{ + sceNp.todo("sceNpManagerGetTicketParam(paramId=%d, param=*0x%x)", paramId, param); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!param) + { + // TODO: check paramId + return SCE_NP_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpManagerGetEntitlementIdList(vm::ptr entIdList, u64 entIdListNum) +{ + sceNp.todo("sceNpManagerGetEntitlementIdList(entIdList=*0x%x, entIdListNum=%d)", entIdList, entIdListNum); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpManagerGetEntitlementById(vm::cptr entId, vm::ptr ent) +{ + sceNp.todo("sceNpManagerGetEntitlementById(entId=%s, ent=*0x%x)", entId, ent); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!entId) + { + return SCE_NP_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpManagerGetSigninId() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpManagerGetTicketParam() +error_code sceNpManagerSubSignin(CellSysutilUserId userId, vm::ptr cb_func, vm::ptr cb_arg, s32 flag) +{ + sceNp.todo("sceNpManagerSubSignin(userId=%d, cb_func=*0x%x, cb_arg=*0x%x, flag=%d)", userId, cb_func, cb_arg, flag); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpManagerSubSigninAbortGui() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpManagerGetEntitlementIdList() +error_code sceNpManagerSubSignout(vm::ptr npId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpManagerSubSignout(npId=*0x%x)", npId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpManagerGetEntitlementById() +error_code sceNpMatchingCreateCtx(vm::ptr npId, vm::ptr handler, vm::ptr arg, vm::ptr ctx_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingCreateCtx(npId=*0x%x, handler=*0x%x, arg=*0x%x, ctx_id=*0x%x)", npId, handler, arg, ctx_id); + return CELL_OK; } -s32 sceNpManagerGetSigninId() +error_code sceNpMatchingDestroyCtx(u32 ctx_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingDestroyCtx(ctx_id=%d)", ctx_id); + return CELL_OK; } -s32 sceNpManagerSubSignin() +error_code sceNpMatchingGetResult(u32 ctx_id, u32 req_id, vm::ptr buf, vm::ptr size, vm::ptr event) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetResult(ctx_id=%d, req_id=%d, buf=*0x%x, size=*0x%x, event=*0x%x)", ctx_id, req_id, buf, size, event); + return CELL_OK; } -s32 sceNpManagerSubSigninAbortGui() +error_code sceNpMatchingGetResultGUI(vm::ptr buf, vm::ptr size, vm::ptr event) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetResultGUI(buf=*0x%x, size=*0x%x, event=*0x%x)", buf, size, event); + return CELL_OK; } -s32 sceNpManagerSubSignout() +error_code sceNpMatchingSetRoomInfo(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, vm::ptr attr, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingSetRoomInfo(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, attr=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, attr, req_id); + return CELL_OK; } -s32 sceNpMatchingCreateCtx() +error_code sceNpMatchingSetRoomInfoNoLimit(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, vm::ptr attr, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingSetRoomInfoNoLimit(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, attr=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, attr, req_id); + return CELL_OK; } -s32 sceNpMatchingDestroyCtx() +error_code sceNpMatchingGetRoomInfo(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, vm::ptr attr, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetRoomInfo(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, attr=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, attr, req_id); + return CELL_OK; } -s32 sceNpMatchingGetResult() +error_code sceNpMatchingGetRoomInfoNoLimit(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, vm::ptr attr, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetRoomInfoNoLimit(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, attr=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, attr, req_id); + return CELL_OK; } -s32 sceNpMatchingGetResultGUI() +error_code sceNpMatchingSetRoomSearchFlag(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, s32 flag, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingSetRoomSearchFlag(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, flag=%d, req_id=*0x%x)", ctx_id, lobby_id, room_id, flag, req_id); + return CELL_OK; } -s32 sceNpMatchingSetRoomInfo() +error_code sceNpMatchingGetRoomSearchFlag(u32 ctx_id, vm::ptr lobby_id, vm::ptr room_id, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetRoomSearchFlag(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, req_id); + return CELL_OK; } -s32 sceNpMatchingSetRoomInfoNoLimit() +error_code sceNpMatchingGetRoomMemberListLocal(u32 ctx_id, vm::ptr room_id, vm::ptr buflen, vm::ptr buf) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetRoomMemberListLocal(ctx_id=%d, room_id=*0x%x, buflen=*0x%x, buf=*0x%x)", ctx_id, room_id, buflen, buf); + return CELL_OK; } -s32 sceNpMatchingGetRoomInfo() +error_code sceNpMatchingGetRoomListLimitGUI(u32 ctx_id, vm::ptr communicationId, vm::ptr range, + vm::ptr cond, vm::ptr attr, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGetRoomListLimitGUI(ctx_id=%d, communicationId=*0x%x, range=*0x%x, cond=*0x%x, attr=*0x%x, handler=*0x%x, arg=*0x%x)", + ctx_id, communicationId, range, cond, attr, handler, arg); + return CELL_OK; } -s32 sceNpMatchingGetRoomInfoNoLimit() +error_code sceNpMatchingKickRoomMember(u32 ctx_id, vm::cptr room_id, vm::cptr user_id, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingKickRoomMember(ctx_id=%d, room_id=*0x%x, user_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, user_id, req_id); + return CELL_OK; } -s32 sceNpMatchingSetRoomSearchFlag() +error_code sceNpMatchingKickRoomMemberWithOpt(u32 ctx_id, vm::cptr room_id, vm::cptr user_id, vm::cptr opt, s32 opt_len, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingKickRoomMemberWithOpt(ctx_id=%d, room_id=*0x%x, user_id=*0x%x, opt=*0x%x, opt_len=%d, req_id=*0x%x)", ctx_id, room_id, user_id, opt, opt_len, req_id); + return CELL_OK; } -s32 sceNpMatchingGetRoomSearchFlag() +error_code sceNpMatchingQuickMatchGUI(u32 ctx_id, vm::cptr communicationId, vm::cptr cond, + s32 available_num, s32 timeout, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingQuickMatchGUI(ctx_id=%d, communicationId=*0x%x, cond=*0x%x, available_num=%d, timeout=%d, handler=*0x%x, arg=*0x%x)", + ctx_id, communicationId, cond, available_num, timeout, handler, arg); + return CELL_OK; } -s32 sceNpMatchingGetRoomMemberListLocal() +error_code sceNpMatchingSendInvitationGUI(u32 ctx_id, vm::cptr room_id, vm::cptr communicationId, vm::cptr dsts, s32 num, + s32 slot_type, vm::cptr subject, vm::cptr body, sys_memory_container_t container, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingSendInvitationGUI(ctx_id=%d, room_id=*0x%x, communicationId=*0x%x, dsts=*0x%x, num=%d, slot_type=%d, subject=%s, body=%s, container=%d, handler=*0x%x, arg=*0x%x)", + ctx_id, room_id, communicationId, dsts, num, slot_type, subject, body, container, handler, arg); + return CELL_OK; } -s32 sceNpMatchingGetRoomListLimitGUI() +error_code sceNpMatchingAcceptInvitationGUI(u32 ctx_id, vm::cptr communicationId, sys_memory_container_t container, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingAcceptInvitationGUI(ctx_id=%d, communicationId=*0x%x, container=%d, handler=*0x%x, arg=*0x%x)", ctx_id, communicationId, container, handler, arg); + return CELL_OK; } -s32 sceNpMatchingKickRoomMember() +error_code sceNpMatchingCreateRoomGUI(u32 ctx_id, vm::cptr communicationId, vm::cptr attr, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingCreateRoomGUI(ctx_id=%d, communicationId=*0x%x, attr=*0x%x, handler=*0x%x, arg=*0x%x)", ctx_id, communicationId, attr, handler, arg); + return CELL_OK; } -s32 sceNpMatchingKickRoomMemberWithOpt() +error_code sceNpMatchingJoinRoomGUI(u32 ctx_id, vm::ptr room_id, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingJoinRoomGUI(ctx_id=%d, room_id=*0x%x, handler=*0x%x, arg=*0x%x)", ctx_id, room_id, handler, arg); + return CELL_OK; } -s32 sceNpMatchingQuickMatchGUI() +error_code sceNpMatchingLeaveRoom(u32 ctx_id, vm::cptr room_id, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingLeaveRoom(ctx_id=%d, room_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, req_id); return CELL_OK; } -s32 sceNpMatchingSendInvitationGUI() +error_code sceNpMatchingSearchJoinRoomGUI(u32 ctx_id, vm::cptr communicationId, vm::cptr cond, + vm::cptr attr, vm::ptr handler, vm::ptr arg) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingSearchJoinRoomGUI(ctx_id=%d, communicationId=*0x%x, cond=*0x%x, attr=*0x%x, handler=*0x%x, arg=*0x%x)", + ctx_id, communicationId, cond, attr, handler, arg); + return CELL_OK; } -s32 sceNpMatchingAcceptInvitationGUI() +error_code sceNpMatchingGrantOwnership(u32 ctx_id, vm::cptr room_id, vm::cptr user_id, vm::ptr req_id) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpMatchingGrantOwnership(ctx_id=%d, room_id=*0x%x, user_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, user_id, req_id); + return CELL_OK; } -s32 sceNpMatchingCreateRoomGUI() +error_code sceNpProfileCallGui(vm::cptr npid, vm::ptr handler, vm::ptr userArg, u64 options) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpProfileCallGui(npid=*0x%x, handler=*0x%x, userArg=*0x%x, options=0x%x)", npid, handler, userArg, options); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + if (!handler) + { + return SCE_NP_PROFILE_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatchingJoinRoomGUI() +error_code sceNpProfileAbortGui() { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpProfileAbortGui()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatchingLeaveRoom() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpMatchingSearchJoinRoomGUI() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpMatchingGrantOwnership() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpProfileCallGui() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpProfileAbortGui() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreInit() +error_code sceNpScoreInit() { sceNp.warning("sceNpScoreInit()"); + const auto score_manager = g_fxo->get(); + + if (score_manager->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED; + } + + score_manager->is_initialized = true; + return CELL_OK; } -s32 sceNpScoreTerm() +error_code sceNpScoreTerm() { sceNp.warning("sceNpScoreTerm()"); + const auto score_manager = g_fxo->get(); + + if (!score_manager->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + score_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpScoreCreateTitleCtx() +error_code sceNpScoreCreateTitleCtx(vm::cptr communicationId, vm::cptr passphrase, vm::cptr selfNpId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpScoreCreateTitleCtx(communicationId=*0x%x, passphrase=*0x%x, selfNpId=*0x%x)", communicationId, passphrase, selfNpId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!communicationId || !passphrase || !selfNpId) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + return CELL_OK; } -s32 sceNpScoreDestroyTitleCtx() +error_code sceNpScoreDestroyTitleCtx(s32 titleCtxId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpScoreDestroyTitleCtx(titleCtxId=%d)", titleCtxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpScoreCreateTransactionCtx(s32 titleCtxId) +error_code sceNpScoreCreateTransactionCtx(s32 titleCtxId) { sceNp.todo("sceNpScoreCreateTransactionCtx(titleCtxId=%d)", titleCtxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + return CELL_OK; } -s32 sceNpScoreDestroyTransactionCtx() +error_code sceNpScoreDestroyTransactionCtx(s32 transId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpScoreDestroyTransactionCtx(transId=%d)", transId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpScoreSetTimeout() +error_code sceNpScoreSetTimeout(s32 ctxId, usecond_t timeout) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpScoreSetTimeout(ctxId=%d, timeout=%d)", ctxId, timeout); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (timeout > 10000000) // 10 seconds + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpScoreSetPlayerCharacterId() +error_code sceNpScoreSetPlayerCharacterId(s32 ctxId, SceNpScorePcId pcId) { - UNIMPLEMENTED_FUNC(sceNp); + sceNp.todo("sceNpScoreSetPlayerCharacterId(ctxId=%d, pcId=%d)", ctxId, pcId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (pcId < 0) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpScoreWaitAsync(s32 transId, vm::ptr result) +error_code sceNpScoreWaitAsync(s32 transId, vm::ptr result) { sceNp.todo("sceNpScoreWaitAsync(transId=%d, result=*0x%x)", transId, result); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + if (transId <= 0) { return SCE_NP_COMMUNITY_ERROR_INVALID_ID; @@ -1564,10 +3025,15 @@ s32 sceNpScoreWaitAsync(s32 transId, vm::ptr result) return CELL_OK; } -s32 sceNpScorePollAsync(s32 transId, vm::ptr result) +error_code sceNpScorePollAsync(s32 transId, vm::ptr result) { sceNp.todo("sceNpScorePollAsync(transId=%d, result=*0x%x)", transId, result); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + if (transId <= 0) { return SCE_NP_COMMUNITY_ERROR_INVALID_ID; @@ -1576,315 +3042,1157 @@ s32 sceNpScorePollAsync(s32 transId, vm::ptr result) return CELL_OK; } -s32 sceNpScoreGetBoardInfo() +error_code sceNpScoreGetBoardInfo(s32 transId, SceNpScoreBoardId boardId, vm::ptr boardInfo, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetBoardInfo(transId=%d, boardId=%d, boardInfo=*0x%x, option=*0x%x)", transId, boardId, boardInfo, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!boardInfo) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetBoardInfoAsync(s32 transId, SceNpScoreBoardId boardId, vm::ptr boardInfo, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetBoardInfo(transId=%d, boardId=%d, boardInfo=*0x%x, prio=%d, option=*0x%x)", transId, boardId, boardInfo, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreRecordScore(s32 transId, SceNpScoreBoardId boardId, SceNpScoreValue score, vm::cptr scoreComment, + vm::cptr gameInfo, vm::ptr tmpRank, vm::ptr option) +{ + sceNp.todo("sceNpScoreRecordScore(transId=%d, boardId=%d, score=%d, scoreComment=*0x%x, gameInfo=*0x%x, tmpRank=*0x%x, option=*0x%x)", + transId, boardId, score, scoreComment, gameInfo, tmpRank, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreRecordScoreAsync(s32 transId, SceNpScoreBoardId boardId, SceNpScoreValue score, vm::cptr scoreComment, + vm::cptr gameInfo, vm::ptr tmpRank, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreRecordScoreAsync(transId=%d, boardId=%d, score=%d, scoreComment=*0x%x, gameInfo=*0x%x, tmpRank=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, score, scoreComment, gameInfo, tmpRank, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreRecordGameData(s32 transId, SceNpScoreBoardId boardId, SceNpScoreValue score, u64 totalSize, u64 sendSize, vm::cptr data, vm::ptr option) +{ + sceNp.todo("sceNpScoreRecordGameData(transId=%d, boardId=%d, score=%d, totalSize=%d, sendSize=%d, data=*0x%x, option=*0x%x)", + transId, boardId, score, totalSize, sendSize, data, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!data) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreRecordGameDataAsync(s32 transId, SceNpScoreBoardId boardId, SceNpScoreValue score, u64 totalSize, u64 sendSize, vm::cptr data, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreRecordGameDataAsync(transId=%d, boardId=%d, score=%d, totalSize=%d, sendSize=%d, data=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, score, totalSize, sendSize, data, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetGameData(s32 transId, SceNpScoreBoardId boardId, vm::cptr npId, vm::ptr totalSize, u64 recvSize, vm::ptr data, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetGameDataAsync(transId=%d, boardId=%d, npId=*0x%x, totalSize=*0x%x, recvSize=%d, data=*0x%x, option=*0x%x)", + transId, boardId, npId, totalSize, recvSize, data, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId || !totalSize || !data) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetGameDataAsync(s32 transId, SceNpScoreBoardId boardId, vm::cptr npId, vm::ptr totalSize, u64 recvSize, vm::ptr data, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetGameDataAsync(transId=%d, boardId=%d, npId=*0x%x, totalSize=*0x%x, recvSize=%d, data=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, npId, totalSize, recvSize, data, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByNpId(s32 transId, SceNpScoreBoardId boardId, vm::cptr npIdArray, u64 npIdArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByNpId(transId=%d, boardId=%d, npIdArray=*0x%x, npIdArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, boardId, npIdArray, npIdArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npIdArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByNpIdAsync(s32 transId, SceNpScoreBoardId boardId, vm::cptr npIdArray, u64 npIdArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByNpIdAsync(transId=%d, boardId=%d, npIdArray=*0x%x, npIdArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, npIdArray, npIdArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npIdArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByRange(s32 transId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByRange(transId=%d, boardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, boardId, startSerialRank, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByRangeAsync(s32 transId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByRangeAsync(transId=%d, boardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, startSerialRank, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetFriendsRanking(s32 transId, SceNpScoreBoardId boardId, s32 includeSelf, vm::ptr rankArray, u64 rankArraySize, + vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetFriendsRanking(transId=%d, boardId=%d, includeSelf=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, boardId, includeSelf, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!rankArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetFriendsRankingAsync(s32 transId, SceNpScoreBoardId boardId, s32 includeSelf, vm::ptr rankArray, u64 rankArraySize, + vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetFriendsRankingAsync(transId=%d, boardId=%d, includeSelf=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, includeSelf, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!rankArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreCensorComment(s32 transId, vm::cptr comment, vm::ptr option) +{ + sceNp.todo("sceNpScoreCensorComment(transId=%d, comment=%s, option=*0x%x)", transId, comment, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!comment) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (strlen(comment.get_ptr()) > SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN || option) // option check at least until fw 4.71 + { + // TODO: is SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN + 1 allowed ? + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreCensorCommentAsync(s32 transId, vm::cptr comment, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreCensorCommentAsync(transId=%d, comment=%s, prio=%d, option=*0x%x)", transId, comment, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!comment) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (strlen(comment.get_ptr()) > SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN || option) // option check at least until fw 4.71 + { + // TODO: is SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN + 1 allowed ? + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreSanitizeComment(s32 transId, vm::cptr comment, vm::ptr sanitizedComment, vm::ptr option) +{ + sceNp.todo("sceNpScoreSanitizeComment(transId=%d, comment=%s, sanitizedComment=*0x%x, option=*0x%x)", transId, comment, sanitizedComment, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!comment) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (strlen(comment.get_ptr()) > SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN || option) // option check at least until fw 4.71 + { + // TODO: is SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN + 1 allowed ? + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreSanitizeCommentAsync(s32 transId, vm::cptr comment, vm::ptr sanitizedComment, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreSanitizeCommentAsync(transId=%d, comment=%s, sanitizedComment=*0x%x, prio=%d, option=*0x%x)", transId, comment, sanitizedComment, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!comment) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (strlen(comment.get_ptr()) > SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN || option) // option check at least until fw 4.71 + { + // TODO: is SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN + 1 allowed ? + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByNpIdPcId(s32 transId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByNpIdPcId(transId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetRankingByNpIdPcIdAsync(s32 transId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + u64 arrayNum, vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetRankingByNpIdPcIdAsync(transId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreAbortTransaction(s32 transId) +{ + sceNp.todo("sceNpScoreAbortTransaction(transId=%d)", transId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByNpId(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, vm::ptr lastSortDate, + vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByNpId(transId=%d, clanId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, clanId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByNpIdAsync(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, vm::ptr lastSortDate, + vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByNpIdAsync(transId=%d, clanId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, clanId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByNpIdPcId(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, vm::ptr lastSortDate, + vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByNpIdPcId(transId=%d, clanId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, clanId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByNpIdPcIdAsync(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, vm::cptr idArray, u64 idArraySize, vm::ptr rankArray, + u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, u64 infoArraySize, + vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, vm::ptr lastSortDate, + vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByNpIdPcIdAsync(transId=%d, clanId=%d, boardId=%d, idArray=*0x%x, idArraySize=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, clanId, boardId, idArray, idArraySize, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!idArray || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansRankingByRange(s32 transId, SceNpScoreClansBoardId clanBoardId, SceNpScoreRankNumber startSerialRank, vm::ptr rankArray, + u64 rankArraySize, vm::ptr reserved1, u64 reservedSize1, vm::ptr reserved2, u64 reservedSize2, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansRankingByRange(transId=%d, clanBoardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, reserved1=*0x%x, reservedSize1=%d, reserved2=*0x%x, reservedSize2=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, clanBoardId, startSerialRank, rankArray, rankArraySize, reserved1, reservedSize1, reserved2, reservedSize2, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_CLAN_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansRankingByRangeAsync(s32 transId, SceNpScoreClansBoardId clanBoardId, SceNpScoreRankNumber startSerialRank, vm::ptr rankArray, + u64 rankArraySize, vm::ptr reserved1, u64 reservedSize1, vm::ptr reserved2, u64 reservedSize2, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansRankingByRangeAsync(transId=%d, clanBoardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, reserved1=*0x%x, reservedSize1=%d, reserved2=*0x%x, reservedSize2=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, clanBoardId, startSerialRank, rankArray, rankArraySize, reserved1, reservedSize1, reserved2, reservedSize2, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClanMemberGameData(s32 transId, SceNpScoreBoardId boardId, SceNpClanId clanId, vm::cptr npId, + vm::ptr totalSize, u64 recvSize, vm::ptr data, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClanMemberGameData(transId=%d, boardId=%d, clanId=%d, npId=*0x%x, totalSize=*0x%x, recvSize=%d, data=*0x%x, option=*0x%x)", + transId, boardId, clanId, npId, totalSize, recvSize, data, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!npId || !totalSize || !data) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClanMemberGameDataAsync(s32 transId, SceNpScoreBoardId boardId, SceNpClanId clanId, vm::cptr npId, + vm::ptr totalSize, u64 recvSize, vm::ptr data, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClanMemberGameDataAsync(transId=%d, boardId=%d, clanId=%d, npId=*0x%x, totalSize=*0x%x, recvSize=%d, data=*0x%x, prio=%d, option=*0x%x)", + transId, boardId, clanId, npId, totalSize, recvSize, data, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansRankingByClanId(s32 transId, SceNpScoreClansBoardId clanBoardId, vm::cptr clanIdArray, u64 clanIdArraySize, + vm::ptr rankArray, u64 rankArraySize, vm::ptr reserved1, u64 reservedSize1, vm::ptr reserved2, u64 reservedSize2, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansRankingByClanId(transId=%d, clanBoardId=%d, clanIdArray=*0x%x, clanIdArraySize=%d, rankArray=*0x%x, rankArraySize=%d, reserved1=*0x%x, reservedSize1=%d, reserved2=*0x%x, reservedSize2=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, clanBoardId, clanIdArray, clanIdArraySize, rankArray, rankArraySize, reserved1, reservedSize1, reserved2, reservedSize2, arrayNum, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!clanIdArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansRankingByClanIdAsync(s32 transId, SceNpScoreClansBoardId clanBoardId, vm::cptr clanIdArray, u64 clanIdArraySize, + vm::ptr rankArray, u64 rankArraySize, vm::ptr reserved1, u64 reservedSize1, vm::ptr reserved2, u64 reservedSize2, u64 arrayNum, + vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansRankingByRangeAsync(transId=%d, clanBoardId=%d, clanIdArray=*0x%x, clanIdArraySize=%d, rankArray=*0x%x, rankArraySize=%d, reserved1=*0x%x, reservedSize1=%d, reserved2=*0x%x, reservedSize2=%d, arrayNum=%d, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, clanBoardId, clanIdArray, clanIdArraySize, rankArray, rankArraySize, reserved1, reservedSize1, reserved2, reservedSize2, arrayNum, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByRange(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, + vm::ptr rankArray, u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, + u64 infoArraySize, vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, + vm::ptr lastSortDate, vm::ptr totalRecord, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByRange(transId=%d, clanId=%d, boardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, option=*0x%x)", + transId, clanId, boardId, startSerialRank, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + if (arrayNum > SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS) + { + return SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; + } + + if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; + } + + return CELL_OK; +} + +error_code sceNpScoreGetClansMembersRankingByRangeAsync(s32 transId, SceNpClanId clanId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, + vm::ptr rankArray, u64 rankArraySize, vm::ptr commentArray, u64 commentArraySize, vm::ptr infoArray, + u64 infoArraySize, vm::ptr descriptArray, u64 descriptArraySize, u64 arrayNum, vm::ptr clanInfo, + vm::ptr lastSortDate, vm::ptr totalRecord, s32 prio, vm::ptr option) +{ + sceNp.todo("sceNpScoreGetClansMembersRankingByRangeAsync(transId=%d, clanId=%d, boardId=%d, startSerialRank=%d, rankArray=*0x%x, rankArraySize=%d, commentArray=*0x%x, commentArraySize=%d, infoArray=*0x%x, infoArraySize=%d, descriptArray=*0x%x, descriptArraySize=%d, arrayNum=%d, clanInfo=*0x%x, lastSortDate=*0x%x, totalRecord=*0x%x, prio=%d, option=*0x%x)", + transId, clanId, boardId, startSerialRank, rankArray, rankArraySize, commentArray, commentArraySize, infoArray, infoArraySize, descriptArray, descriptArraySize, arrayNum, clanInfo, lastSortDate, totalRecord, prio, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + if (!arrayNum) + { + return SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; + } + + if (!startSerialRank || option) // option check at least until fw 4.71 + { + return SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingCreateCtx(vm::ptr npId, vm::ptr handler, vm::ptr arg, vm::ptr ctx_id) +{ + sceNp.todo("sceNpSignalingCreateCtx(npId=*0x%x, handler=*0x%x, arg=*0x%x, ctx_id=*0x%x)", npId, handler, arg, ctx_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!npId || !ctx_id) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + //if (current_contexts > SCE_NP_SIGNALING_CTX_MAX) + //{ + // return SCE_NP_SIGNALING_ERROR_CTX_MAX; + //} + + return CELL_OK; +} + +error_code sceNpSignalingDestroyCtx(u32 ctx_id) +{ + sceNp.todo("sceNpSignalingDestroyCtx(ctx_id=%d)", ctx_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpSignalingAddExtendedHandler(u32 ctx_id, vm::ptr handler, vm::ptr arg) +{ + sceNp.todo("sceNpSignalingAddExtendedHandler(ctx_id=%d, handler=*0x%x, arg=*0x%x)", ctx_id, handler, arg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpSignalingSetCtxOpt(u32 ctx_id, s32 optname, s32 optval) +{ + sceNp.todo("sceNpSignalingSetCtxOpt(ctx_id=%d, optname=%d, optval=%d)", ctx_id, optname, optval); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!optname || !optval) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetCtxOpt(u32 ctx_id, s32 optname, vm::ptr optval) +{ + sceNp.todo("sceNpSignalingGetCtxOpt(ctx_id=%d, optname=%d, optval=*0x%x)", ctx_id, optname, optval); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!optname || !optval) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingActivateConnection(u32 ctx_id, vm::ptr npId, u32 conn_id) +{ + sceNp.todo("sceNpSignalingActivateConnection(ctx_id=%d, npId=*0x%x, conn_id=%d)", ctx_id, npId, conn_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!npId || !conn_id) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingDeactivateConnection(u32 ctx_id, u32 conn_id) +{ + sceNp.todo("sceNpSignalingDeactivateConnection(ctx_id=%d, conn_id=%d)", ctx_id, conn_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpSignalingTerminateConnection(u32 ctx_id, u32 conn_id) +{ + sceNp.todo("sceNpSignalingTerminateConnection(ctx_id=%d, conn_id=%d)", ctx_id, conn_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetConnectionStatus(u32 ctx_id, u32 conn_id, vm::ptr conn_status, vm::ptr peer_addr, vm::ptr peer_port) +{ + sceNp.todo("sceNpSignalingGetConnectionStatus(ctx_id=%d, conn_id=%d, conn_status=*0x%x, peer_addr=*0x%x, peer_port=*0x%x)", ctx_id, conn_id, conn_status, peer_addr, peer_port); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!conn_status) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetConnectionInfo(u32 ctx_id, u32 conn_id, s32 code, vm::ptr info) +{ + sceNp.todo("sceNpSignalingGetConnectionInfo(ctx_id=%d, conn_id=%d, code=%d, info=*0x%x)", ctx_id, conn_id, code, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetConnectionFromNpId(u32 ctx_id, vm::ptr npId, vm::ptr conn_id) +{ + sceNp.todo("sceNpSignalingGetConnectionFromNpId(ctx_id=%d, npId=*0x%x, conn_id=*0x%x)", ctx_id, npId, conn_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!npId || !conn_id) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetConnectionFromPeerAddress(u32 ctx_id, vm::ptr peer_addr, in_port_t peer_port, vm::ptr conn_id) +{ + sceNp.todo("sceNpSignalingGetConnectionFromPeerAddress(ctx_id=%d, peer_addr=*0x%x, peer_port=%d, conn_id=*0x%x)", ctx_id, peer_addr, peer_port, conn_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!conn_id) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetLocalNetInfo(u32 ctx_id, vm::ptr info) +{ + sceNp.todo("sceNpSignalingGetLocalNetInfo(ctx_id=%d, info=*0x%x)", ctx_id, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + // TODO: check info->size + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetPeerNetInfo(u32 ctx_id, vm::ptr npId, vm::ptr req_id) +{ + sceNp.todo("sceNpSignalingGetPeerNetInfo(ctx_id=%d, npId=*0x%x, req_id=*0x%x)", ctx_id, npId, req_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!npId || !req_id) + { + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpSignalingCancelPeerNetInfo(u32 ctx_id, u32 req_id) +{ + sceNp.todo("sceNpSignalingCancelPeerNetInfo(ctx_id=%d, req_id=%d)", ctx_id, req_id); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + return CELL_OK; +} + +error_code sceNpSignalingGetPeerNetInfoResult(u32 ctx_id, u32 req_id, vm::ptr info) +{ + sceNp.todo("sceNpSignalingGetPeerNetInfoResult(ctx_id=%d, req_id=%d, info=*0x%x)", ctx_id, req_id, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + // TODO: check info->size + return SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; + } + + return CELL_OK; +} + +error_code sceNpUtilCanonicalizeNpIdForPs3() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpScoreGetBoardInfoAsync() +error_code sceNpUtilCanonicalizeNpIdForPsp() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpScoreRecordScore() +error_code sceNpUtilCmpNpId(vm::ptr id1, vm::ptr id2) { - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} + sceNp.todo("sceNpUtilCmpNpId(id1=*0x%x, id2=*0x%x)", id1, id2); -s32 sceNpScoreRecordScoreAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreRecordGameData() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreRecordGameDataAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetGameData() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetGameDataAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByNpId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByNpIdAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByRange() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByRangeAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetFriendsRanking() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetFriendsRankingAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreCensorComment() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreCensorCommentAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreSanitizeComment() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreSanitizeCommentAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByNpIdPcId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetRankingByNpIdPcIdAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreAbortTransaction() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByNpId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByNpIdAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByNpIdPcId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByNpIdPcIdAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansRankingByRange() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansRankingByRangeAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClanMemberGameData() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClanMemberGameDataAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansRankingByClanId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansRankingByClanIdAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByRange() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpScoreGetClansMembersRankingByRangeAsync() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingCreateCtx() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingDestroyCtx() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingAddExtendedHandler() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingSetCtxOpt() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetCtxOpt() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingActivateConnection() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingDeactivateConnection() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingTerminateConnection() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetConnectionStatus() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetConnectionInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetConnectionFromNpId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetConnectionFromPeerAddress() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetLocalNetInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetPeerNetInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingCancelPeerNetInfo() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpSignalingGetPeerNetInfoResult() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpUtilCanonicalizeNpIdForPs3() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpUtilCanonicalizeNpIdForPsp() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpUtilCmpNpId(vm::ptr id1, vm::ptr id2) -{ - sceNp.warning("sceNpUtilCmpNpId(id1=*0x%x, id2=*0x%x)", id1, id2); + if (!id1 || !id2) + { + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } // TODO: Improve the comparison. if (strcmp(id1->handle.data, id2->handle.data) != 0) @@ -1895,37 +4203,81 @@ s32 sceNpUtilCmpNpId(vm::ptr id1, vm::ptr id2) return CELL_OK; } -s32 sceNpUtilCmpNpIdInOrder() +error_code sceNpUtilCmpNpIdInOrder(vm::cptr id1, vm::cptr id2, vm::ptr order) +{ + sceNp.todo("sceNpUtilCmpNpIdInOrder(id1=*0x%x, id2=*0x%x, order=*0x%x)", id1, id2, order); + + if (!id1 || !id2) + { + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } + + // TODO: Improve the comparison. + // TODO: check for nullptr + order.set(strcmp(id1->handle.data, id2->handle.data)); + + return CELL_OK; +} + +error_code sceNpUtilCmpOnlineId(vm::cptr id1, vm::cptr id2) +{ + sceNp.todo("sceNpUtilCmpOnlineId(id1=*0x%x, id2=*0x%x)", id1, id2); + + if (!id1 || !id2) + { + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } + + // TODO: Improve the comparison. + if (strcmp(id1->handle.data, id2->handle.data) != 0) + { + return SCE_NP_UTIL_ERROR_NOT_MATCH; + } + + return CELL_OK; +} + +error_code sceNpUtilGetPlatformType(vm::cptr npId) +{ + sceNp.todo("sceNpUtilGetPlatformType(npId=*0x%x)", npId); + + if (!npId) + { + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } + + //if (unknown_platform) + //{ + // return SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE; + //} + + return CELL_OK; // SCE_NP_PLATFORM_TYPE_NONE +} + +error_code sceNpUtilSetPlatformType(vm::ptr npId, SceNpPlatformType platformType) +{ + sceNp.todo("sceNpUtilSetPlatformType(npId=*0x%x, platformType=%d)", npId, platformType); + + if (!npId) + { + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } + + if (platformType < SCE_NP_PLATFORM_TYPE_NONE || platformType > SCE_NP_PLATFORM_TYPE_VITA) + { + return SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE; + } + + return CELL_OK; +} + +error_code _sceNpSysutilClientMalloc() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } -s32 sceNpUtilCmpOnlineId() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpUtilGetPlatformType() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 sceNpUtilSetPlatformType() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 _sceNpSysutilClientMalloc() -{ - UNIMPLEMENTED_FUNC(sceNp); - return CELL_OK; -} - -s32 _sceNpSysutilClientFree() +error_code _sceNpSysutilClientFree() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; diff --git a/rpcs3/Emu/Cell/Modules/sceNp.h b/rpcs3/Emu/Cell/Modules/sceNp.h index 069c33f439..f2003afc60 100644 --- a/rpcs3/Emu/Cell/Modules/sceNp.h +++ b/rpcs3/Emu/Cell/Modules/sceNp.h @@ -1,11 +1,52 @@ -#pragma once +#pragma once #include "cellRtc.h" #include "Utilities/BEType.h" +#include + +using in_addr_t = u32; +using in_port_t = u16; +using sa_family_t = u8; +using socklen_t = u32; + +struct in_addr +{ + in_addr_t s_addr; // TODO: alignment? +}; + +using sys_memory_container_t = u32; + +using system_time_t = s64; +using second_t = u32; +using usecond_t = u64; + +using SceNpBasicAttachmentDataId = u32; +using SceNpBasicMessageId = u64; +using SceNpBasicMessageRecvAction = u32; + +using SceNpClanId = u32; +using SceNpClansMessageId = u32; +using SceNpClansMemberStatus = s32; + +using SceNpCustomMenuIndexMask = u32; +using SceNpCustomMenuSelectedType = u32; + +using SceNpFriendlistCustomOptions = u64; + +using SceNpPlatformType = s32; + +using SceNpScoreBoardId = u32; +using SceNpScoreClansBoardId = u32; +using SceNpScorePcId = s32; +using SceNpScoreRankNumber = u32; +using SceNpScoreValue = s64; + +using SceNpTime = s64; + // Error Codes -enum +enum SceNpError : u32 { // NP Manager Utility SCE_NP_ERROR_NOT_INITIALIZED = 0x8002aa01, @@ -83,6 +124,30 @@ enum SCE_NP_UTIL_ERROR_UNKNOWN_TYPE = 0x8002ab0d, SCE_NP_UTIL_ERROR_UNKNOWN = 0x8002ab0e, SCE_NP_UTIL_ERROR_NOT_MATCH = 0x8002ab0f, + SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE = 0x8002ab10, + + // NP Friendlist Utility + SCE_NP_FRIENDLIST_ERROR_ALREADY_INITIALIZED = 0x8002ab20, + SCE_NP_FRIENDLIST_ERROR_NOT_INITIALIZED = 0x8002ab21, + SCE_NP_FRIENDLIST_ERROR_OUT_OF_MEMORY = 0x8002ab22, + SCE_NP_FRIENDLIST_ERROR_INVALID_MEMORY_CONTAINER = 0x8002ab23, + SCE_NP_FRIENDLIST_ERROR_INSUFFICIENT = 0x8002ab24, + SCE_NP_FRIENDLIST_ERROR_CANCEL = 0x8002ab25, + SCE_NP_FRIENDLIST_ERROR_STATUS = 0x8002ab26, + SCE_NP_FRIENDLIST_ERROR_BUSY = 0x8002ab27, + SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT = 0x8002ab28, + + // NP Profile Utility + SCE_NP_PROFILE_ERROR_ALREADY_INITIALIZED = 0x8002ab40, + SCE_NP_PROFILE_ERROR_NOT_INITIALIZED = 0x8002ab41, + SCE_NP_PROFILE_ERROR_OUT_OF_MEMORY = 0x8002ab42, + SCE_NP_PROFILE_ERROR_NOT_SUPPORTED = 0x8002ab43, + SCE_NP_PROFILE_ERROR_INSUFFICIENT = 0x8002ab44, + SCE_NP_PROFILE_ERROR_CANCEL = 0x8002ab45, + SCE_NP_PROFILE_ERROR_STATUS = 0x8002ab46, + SCE_NP_PROFILE_ERROR_BUSY = 0x8002ab47, + SCE_NP_PROFILE_ERROR_INVALID_ARGUMENT = 0x8002ab48, + SCE_NP_PROFILE_ERROR_ABORT = 0x8002ab49, // NP Community Utility SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED = 0x8002a101, @@ -117,6 +182,64 @@ enum SCE_NP_COMMUNITY_ERROR_INVALID_PARTITION = 0x8002a1af, SCE_NP_COMMUNITY_ERROR_TOO_MANY_SLOTID = 0x8002a1b1, + // NP Community Server + SCE_NP_COMMUNITY_SERVER_ERROR_BAD_REQUEST = 0x8002a401, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_TICKET = 0x8002a402, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SIGNATURE = 0x8002a403, + SCE_NP_COMMUNITY_SERVER_ERROR_EXPIRED_TICKET = 0x8002a404, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_NPID = 0x8002a405, + SCE_NP_COMMUNITY_SERVER_ERROR_FORBIDDEN = 0x8002a406, + SCE_NP_COMMUNITY_SERVER_ERROR_INTERNAL_SERVER_ERROR = 0x8002a407, + SCE_NP_COMMUNITY_SERVER_ERROR_VERSION_NOT_SUPPORTED = 0x8002a408, + SCE_NP_COMMUNITY_SERVER_ERROR_SERVICE_UNAVAILABLE = 0x8002a409, + SCE_NP_COMMUNITY_SERVER_ERROR_PLAYER_BANNED = 0x8002a40a, + SCE_NP_COMMUNITY_SERVER_ERROR_CENSORED = 0x8002a40b, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_RECORD_FORBIDDEN = 0x8002a40c, + SCE_NP_COMMUNITY_SERVER_ERROR_USER_PROFILE_NOT_FOUND = 0x8002a40d, + SCE_NP_COMMUNITY_SERVER_ERROR_UPLOADER_DATA_NOT_FOUND = 0x8002a40e, + SCE_NP_COMMUNITY_SERVER_ERROR_QUOTA_MASTER_NOT_FOUND = 0x8002a40f, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_TITLE_NOT_FOUND = 0x8002a410, + SCE_NP_COMMUNITY_SERVER_ERROR_BLACKLISTED_USER_ID = 0x8002a411, + SCE_NP_COMMUNITY_SERVER_ERROR_GAME_RANKING_NOT_FOUND = 0x8002a412, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_STORE_NOT_FOUND = 0x8002a414, + SCE_NP_COMMUNITY_SERVER_ERROR_NOT_BEST_SCORE = 0x8002a415, + SCE_NP_COMMUNITY_SERVER_ERROR_LATEST_UPDATE_NOT_FOUND = 0x8002a416, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BOARD_MASTER_NOT_FOUND = 0x8002a417, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_GAME_DATA_MASTER_NOT_FOUND = 0x8002a418, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ANTICHEAT_DATA = 0x8002a419, + SCE_NP_COMMUNITY_SERVER_ERROR_TOO_LARGE_DATA = 0x8002a41a, + SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_USER_NPID = 0x8002a41b, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ENVIRONMENT = 0x8002a41d, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_CHARACTER = 0x8002a41f, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_LENGTH = 0x8002a420, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_CHARACTER = 0x8002a421, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_LENGTH = 0x8002a422, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SCORE = 0x8002a423, + SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_RANKING_LIMIT = 0x8002a424, + SCE_NP_COMMUNITY_SERVER_ERROR_FAIL_TO_CREATE_SIGNATURE = 0x8002a426, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MASTER_INFO_NOT_FOUND = 0x8002a427, + SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_GAME_DATA_LIMIT = 0x8002a428, + SCE_NP_COMMUNITY_SERVER_ERROR_SELF_DATA_NOT_FOUND = 0x8002a42a, + SCE_NP_COMMUNITY_SERVER_ERROR_USER_NOT_ASSIGNED = 0x8002a42b, + SCE_NP_COMMUNITY_SERVER_ERROR_GAME_DATA_ALREADY_EXISTS = 0x8002a42c, + SCE_NP_COMMUNITY_SERVER_ERROR_TOO_MANY_RESULTS = 0x8002a42d, + SCE_NP_COMMUNITY_SERVER_ERROR_NOT_RECORDABLE_VERSION = 0x8002a42e, + SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_TITLE_MASTER_NOT_FOUND = 0x8002a448, + SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_VIRTUAL_USER = 0x8002a449, + SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_DATA_NOT_FOUND = 0x8002a44a, + SCE_NP_COMMUNITY_SERVER_ERROR_CONDITIONS_NOT_SATISFIED = 0x8002a473, + SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_BEFORE_SERVICE = 0x8002a4a0, + SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_END_OF_SERVICE = 0x8002a4a1, + SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_MAINTENANCE = 0x8002a4a2, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BEFORE_SERVICE = 0x8002a4a3, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_END_OF_SERVICE = 0x8002a4a4, + SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MAINTENANCE = 0x8002a4a5, + SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_TITLE = 0x8002a4a6, + SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_BEFORE_SERVICE = 0x8002a4aa, + SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_END_OF_SERVICE = 0x8002a4ab, + SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_MAINTENANCE = 0x8002a4ac, + SCE_NP_COMMUNITY_SERVER_ERROR_UNSPECIFIED = 0x8002a4ff, + // DRM SCE_NP_DRM_ERROR_LICENSE_NOT_FOUND = 0x80029521, SCE_NP_DRM_ERROR_OUT_OF_MEMORY = 0x80029501, @@ -138,9 +261,239 @@ enum SCE_NP_DRM_ERROR_FORMAT = 0x80029530, SCE_NP_DRM_ERROR_FILENAME = 0x80029533, SCE_NP_DRM_ERROR_K_LICENSEE = 0x80029534, + + // Auth + SCE_NP_AUTH_EINVAL = 0x8002a002, + SCE_NP_AUTH_ENOMEM = 0x8002a004, + SCE_NP_AUTH_ESRCH = 0x8002a005, + SCE_NP_AUTH_EBUSY = 0x8002a00a, + SCE_NP_AUTH_EABORT = 0x8002a00c, + SCE_NP_AUTH_EEXIST = 0x8002a014, + SCE_NP_AUTH_EINVALID_ARGUMENT = 0x8002a015, + + // Auth extended + SCE_NP_AUTH_ERROR_SERVICE_END = 0x8002a200, + SCE_NP_AUTH_ERROR_SERVICE_DOWN = 0x8002a201, + SCE_NP_AUTH_ERROR_SERVICE_BUSY = 0x8002a202, + SCE_NP_AUTH_ERROR_SERVER_MAINTENANCE = 0x8002a203, + SCE_NP_AUTH_ERROR_INVALID_DATA_LENGTH = 0x8002a210, + SCE_NP_AUTH_ERROR_INVALID_USER_AGENT = 0x8002a211, + SCE_NP_AUTH_ERROR_INVALID_VERSION = 0x8002a212, + SCE_NP_AUTH_ERROR_INVALID_SERVICE_ID = 0x8002a220, + SCE_NP_AUTH_ERROR_INVALID_CREDENTIAL = 0x8002a221, + SCE_NP_AUTH_ERROR_INVALID_ENTITLEMENT_ID = 0x8002a222, + SCE_NP_AUTH_ERROR_INVALID_CONSUMED_COUNT = 0x8002a223, + SCE_NP_AUTH_ERROR_INVALID_CONSOLE_ID = 0x8002a224, + SCE_NP_AUTH_ERROR_CONSOLE_ID_SUSPENDED = 0x8002a227, + SCE_NP_AUTH_ERROR_ACCOUNT_CLOSED = 0x8002a230, + SCE_NP_AUTH_ERROR_ACCOUNT_SUSPENDED = 0x8002a231, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_EULA = 0x8002a232, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT1 = 0x8002a240, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT2 = 0x8002a241, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT3 = 0x8002a242, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT4 = 0x8002a243, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT5 = 0x8002a244, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT6 = 0x8002a245, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT7 = 0x8002a246, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT8 = 0x8002a247, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT9 = 0x8002a248, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT10 = 0x8002a249, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT11 = 0x8002a24a, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT12 = 0x8002a24b, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT13 = 0x8002a24c, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT14 = 0x8002a24d, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT15 = 0x8002a24e, + SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT16 = 0x8002a24f, + SCE_NP_AUTH_ERROR_UNKNOWN = 0x8002a280, + + // Core Utility + SCE_NP_CORE_UTIL_ERROR_INVALID_ARGUMENT = 0x8002a501, + SCE_NP_CORE_UTIL_ERROR_OUT_OF_MEMORY = 0x8002a502, + SCE_NP_CORE_UTIL_ERROR_INSUFFICIENT = 0x8002a503, + SCE_NP_CORE_UTIL_ERROR_PARSER_FAILED = 0x8002a504, + SCE_NP_CORE_UTIL_ERROR_INVALID_PROTOCOL_ID = 0x8002a505, + SCE_NP_CORE_UTIL_ERROR_INVALID_EXTENSION = 0x8002a506, + SCE_NP_CORE_UTIL_ERROR_INVALID_TEXT = 0x8002a507, + SCE_NP_CORE_UTIL_ERROR_UNKNOWN_TYPE = 0x8002a508, + SCE_NP_CORE_UTIL_ERROR_UNKNOWN = 0x8002a509, + + // Core Parser + SCE_NP_CORE_PARSER_ERROR_NOT_INITIALIZED = 0x8002a511, + SCE_NP_CORE_PARSER_ERROR_ALREADY_INITIALIZED = 0x8002a512, + SCE_NP_CORE_PARSER_ERROR_OUT_OF_MEMORY = 0x8002a513, + SCE_NP_CORE_PARSER_ERROR_INSUFFICIENT = 0x8002a514, + SCE_NP_CORE_PARSER_ERROR_INVALID_FORMAT = 0x8002a515, + SCE_NP_CORE_PARSER_ERROR_INVALID_ARGUMENT = 0x8002a516, + SCE_NP_CORE_PARSER_ERROR_INVALID_HANDLE = 0x8002a517, + SCE_NP_CORE_PARSER_ERROR_INVALID_ICON = 0x8002a518, + SCE_NP_CORE_PARSER_ERROR_UNKNOWN = 0x8002a519, + + // Core Errors + SCE_NP_CORE_ERROR_ALREADY_INITIALIZED = 0x8002a521, + SCE_NP_CORE_ERROR_NOT_INITIALIZED = 0x8002a522, + SCE_NP_CORE_ERROR_INVALID_ARGUMENT = 0x8002a523, + SCE_NP_CORE_ERROR_OUT_OF_MEMORY = 0x8002a524, + SCE_NP_CORE_ERROR_ID_NOT_AVAILABLE = 0x8002a525, + SCE_NP_CORE_ERROR_USER_OFFLINE = 0x8002a526, + SCE_NP_CORE_ERROR_SESSION_RUNNING = 0x8002a527, + SCE_NP_CORE_ERROR_SESSION_NOT_ESTABLISHED = 0x8002a528, + SCE_NP_CORE_ERROR_SESSION_INVALID_STATE = 0x8002a529, + SCE_NP_CORE_ERROR_SESSION_ID_TOO_LONG = 0x8002a52a, + SCE_NP_CORE_ERROR_SESSION_INVALID_NAMESPACE = 0x8002a52b, + SCE_NP_CORE_ERROR_CONNECTION_TIMEOUT = 0x8002a52c, + SCE_NP_CORE_ERROR_GETSOCKOPT = 0x8002a52d, + SCE_NP_CORE_ERROR_SSL_NOT_INITIALIZED = 0x8002a52e, + SCE_NP_CORE_ERROR_SSL_ALREADY_INITIALIZED = 0x8002a52f, + SCE_NP_CORE_ERROR_SSL_NO_CERT = 0x8002a530, + SCE_NP_CORE_ERROR_SSL_NO_TRUSTWORTHY_CA = 0x8002a531, + SCE_NP_CORE_ERROR_SSL_INVALID_CERT = 0x8002a532, + SCE_NP_CORE_ERROR_SSL_CERT_VERIFY = 0x8002a533, + SCE_NP_CORE_ERROR_SSL_CN_CHECK = 0x8002a534, + SCE_NP_CORE_ERROR_SSL_HANDSHAKE_FAILED = 0x8002a535, + SCE_NP_CORE_ERROR_SSL_SEND = 0x8002a536, + SCE_NP_CORE_ERROR_SSL_RECV = 0x8002a537, + SCE_NP_CORE_ERROR_SSL_CREATE_CTX = 0x8002a538, + SCE_NP_CORE_ERROR_PARSE_PEM = 0x8002a539, + SCE_NP_CORE_ERROR_INVALID_INITIATE_STREAM = 0x8002a53a, + SCE_NP_CORE_ERROR_SASL_NOT_SUPPORTED = 0x8002a53b, + SCE_NP_CORE_ERROR_NAMESPACE_ALREADY_EXISTS = 0x8002a53c, + SCE_NP_CORE_ERROR_FROM_ALREADY_EXISTS = 0x8002a53d, + SCE_NP_CORE_ERROR_MODULE_NOT_REGISTERED = 0x8002a53e, + SCE_NP_CORE_ERROR_MODULE_FROM_NOT_FOUND = 0x8002a53f, + SCE_NP_CORE_ERROR_UNKNOWN_NAMESPACE = 0x8002a540, + SCE_NP_CORE_ERROR_INVALID_VERSION = 0x8002a541, + SCE_NP_CORE_ERROR_LOGIN_TIMEOUT = 0x8002a542, + SCE_NP_CORE_ERROR_TOO_MANY_SESSIONS = 0x8002a543, + SCE_NP_CORE_ERROR_SENDLIST_NOT_FOUND = 0x8002a544, + SCE_NP_CORE_ERROR_NO_ID = 0x8002a545, + SCE_NP_CORE_ERROR_LOAD_CERTS = 0x8002a546, + SCE_NP_CORE_ERROR_NET_SELECT = 0x8002a547, + SCE_NP_CORE_ERROR_DISCONNECTED = 0x8002a548, + SCE_NP_CORE_ERROR_TICKET_TOO_SMALL = 0x8002a549, + SCE_NP_CORE_ERROR_INVALID_TICKET = 0x8002a54a, + SCE_NP_CORE_ERROR_INVALID_ONLINEID = 0x8002a54b, + SCE_NP_CORE_ERROR_GETHOSTBYNAME = 0x8002a54c, + SCE_NP_CORE_ERROR_UNDEFINED_STREAM_ERROR = 0x8002a54d, + SCE_NP_CORE_ERROR_INTERNAL = 0x8002a5ff, + + // Core DNS + SCE_NP_CORE_ERROR_DNS_HOST_NOT_FOUND = 0x8002af01, + SCE_NP_CORE_ERROR_DNS_TRY_AGAIN = 0x8002af02, + SCE_NP_CORE_ERROR_DNS_NO_RECOVERY = 0x8002af03, + SCE_NP_CORE_ERROR_DNS_NO_DATA = 0x8002af04, + SCE_NP_CORE_ERROR_DNS_NO_ADDRESS = 0x8002afff, + + // Core Server + SCE_NP_CORE_SERVER_ERROR_CONFLICT = 0x8002a303, + SCE_NP_CORE_SERVER_ERROR_NOT_AUTHORIZED = 0x8002a30d, + SCE_NP_CORE_SERVER_ERROR_REMOTE_CONNECTION_FAILED = 0x8002a30f, + SCE_NP_CORE_SERVER_ERROR_RESOURCE_CONSTRAINT = 0x8002a310, + SCE_NP_CORE_SERVER_ERROR_SYSTEM_SHUTDOWN = 0x8002a313, + SCE_NP_CORE_SERVER_ERROR_UNSUPPORTED_CLIENT_VERSION = 0x8002a319, + + // Signaling + SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED = 0x8002a801, + SCE_NP_SIGNALING_ERROR_ALREADY_INITIALIZED = 0x8002a802, + SCE_NP_SIGNALING_ERROR_OUT_OF_MEMORY = 0x8002a803, + SCE_NP_SIGNALING_ERROR_CTXID_NOT_AVAILABLE = 0x8002a804, + SCE_NP_SIGNALING_ERROR_CTX_NOT_FOUND = 0x8002a805, + SCE_NP_SIGNALING_ERROR_REQID_NOT_AVAILABLE = 0x8002a806, + SCE_NP_SIGNALING_ERROR_REQ_NOT_FOUND = 0x8002a807, + SCE_NP_SIGNALING_ERROR_PARSER_CREATE_FAILED = 0x8002a808, + SCE_NP_SIGNALING_ERROR_PARSER_FAILED = 0x8002a809, + SCE_NP_SIGNALING_ERROR_INVALID_NAMESPACE = 0x8002a80a, + SCE_NP_SIGNALING_ERROR_NETINFO_NOT_AVAILABLE = 0x8002a80b, + SCE_NP_SIGNALING_ERROR_PEER_NOT_RESPONDING = 0x8002a80c, + SCE_NP_SIGNALING_ERROR_CONNID_NOT_AVAILABLE = 0x8002a80d, + SCE_NP_SIGNALING_ERROR_CONN_NOT_FOUND = 0x8002a80e, + SCE_NP_SIGNALING_ERROR_PEER_UNREACHABLE = 0x8002a80f, + SCE_NP_SIGNALING_ERROR_TERMINATED_BY_PEER = 0x8002a810, + SCE_NP_SIGNALING_ERROR_TIMEOUT = 0x8002a811, + SCE_NP_SIGNALING_ERROR_CTX_MAX = 0x8002a812, + SCE_NP_SIGNALING_ERROR_RESULT_NOT_FOUND = 0x8002a813, + SCE_NP_SIGNALING_ERROR_CONN_IN_PROGRESS = 0x8002a814, + SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT = 0x8002a815, + SCE_NP_SIGNALING_ERROR_OWN_NP_ID = 0x8002a816, + SCE_NP_SIGNALING_ERROR_TOO_MANY_CONN = 0x8002a817, + SCE_NP_SIGNALING_ERROR_TERMINATED_BY_MYSELF = 0x8002a818, + + // Custom Menu + SCE_NP_CUSTOM_MENU_ERROR_ALREADY_INITIALIZED = 0x80023b01, + SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED = 0x80023b02, + SCE_NP_CUSTOM_MENU_ERROR_OUT_OF_MEMORY = 0x80023b03, + SCE_NP_CUSTOM_MENU_ERROR_NOT_SUPPORTED = 0x80023b04, + SCE_NP_CUSTOM_MENU_ERROR_INSUFFICIENT = 0x80023b05, + SCE_NP_CUSTOM_MENU_ERROR_CANCEL = 0x80023b06, + SCE_NP_CUSTOM_MENU_ERROR_STATUS = 0x80023b07, + SCE_NP_CUSTOM_MENU_ERROR_BUSY = 0x80023b08, + SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT = 0x80023b09, + SCE_NP_CUSTOM_MENU_ERROR_ABORT = 0x80023b0a, + SCE_NP_CUSTOM_MENU_ERROR_NOT_REGISTERED = 0x80023b0b, + SCE_NP_CUSTOM_MENU_ERROR_EXCEEDS_MAX = 0x80023b0c, + SCE_NP_CUSTOM_MENU_ERROR_INVALID_CHARACTER = 0x80023b0d, }; -using SceNpBasicEventHandler = s32(s32 event, s32 retCode, u32 reqId, vm::ptr arg); +// Basic presence options +enum +{ + SCE_NP_BASIC_PRESENCE_OPTIONS_SET_DATA = 0x00000001, + SCE_NP_BASIC_PRESENCE_OPTIONS_SET_STATUS = 0x00000002, + SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS = 0x00000003, // sum of all other options +}; + +// Basic presence states +enum +{ + SCE_NP_BASIC_PRESENCE_STATE_OFFLINE = 0, + SCE_NP_BASIC_PRESENCE_STATE_OUT_OF_CONTEXT = 1, + SCE_NP_BASIC_PRESENCE_STATE_IN_CONTEXT = 2 +}; + +// Basic player options +enum +{ + SCE_NP_BASIC_PLAYERS_HISTORY_OPTIONS_BY_NP_COMM_ID = 0, + SCE_NP_BASIC_PLAYERS_HISTORY_OPTIONS_ALL = 1 +}; + +// Custom menu selection types +enum : SceNpCustomMenuSelectedType +{ + SCE_NP_CUSTOM_MENU_SELECTED_TYPE_ME = 1, + SCE_NP_CUSTOM_MENU_SELECTED_TYPE_FRIEND = 2, + SCE_NP_CUSTOM_MENU_SELECTED_TYPE_PLAYER = 3, +}; + +// Custom menu action masks +enum SceNpCustomMenuActionMask : u32 +{ + SCE_NP_CUSTOM_MENU_ACTION_MASK_ME = 0x00000001, + SCE_NP_CUSTOM_MENU_ACTION_MASK_FRIEND = 0x00000002, + SCE_NP_CUSTOM_MENU_ACTION_MASK_PLAYER = 0x00000004, + SCE_NP_CUSTOM_MENU_ACTION_MASK_ALL = 0x00000007 // sum of all other masks +}; + +// Custom menu index mask +enum +{ + SCE_NP_CUSTOM_MENU_INDEX_BITS = (sizeof(SceNpCustomMenuIndexMask) * 8), + SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL = ((SceNpCustomMenuIndexMask) - 1), + SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT = 5, + SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK = (SCE_NP_CUSTOM_MENU_INDEX_BITS - 1), + SCE_NP_CUSTOM_MENU_INDEX_BITS_MAX = 127, + SCE_NP_CUSTOM_MENU_INDEX_SETSIZE = 128, +}; + +#define SCE_NP_CUSTOM_MENU_INDEX_SET(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] |= (1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK))) +#define SCE_NP_CUSTOM_MENU_INDEX_CLR(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] &= ~(1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK))) +#define SCE_NP_CUSTOM_MENU_INDEX_ISSET(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] & (1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK))) +#define SCE_NP_CUSTOM_MENU_INDEX_ZERO(p) ( for (u32 i = 0; i < (SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT); i++) p->index_bits[i] = 0; ) +#define SCE_NP_CUSTOM_MENU_INDEX_SET_ALL(p) ( for (u32 i = 0; i < (SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT); i++) p->index_bits[i] = SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL; ) + +enum +{ + SCE_NP_DRM_OPEN_FLAG = 2 +}; // NP Manager Utility statuses enum @@ -185,9 +538,10 @@ enum }; // IDs for attachment data objects -enum +enum : SceNpBasicAttachmentDataId { SCE_NP_BASIC_INVALID_ATTACHMENT_DATA_ID = 0, + SCE_NP_BASIC_INVALID_MESSAGE_ID = 0, SCE_NP_BASIC_SELECTED_INVITATION_DATA = 1, SCE_NP_BASIC_SELECTED_MESSAGE_DATA = 2, }; @@ -202,7 +556,7 @@ enum }; // Main types of messages -enum +enum SceNpBasicMessageMainType : u16 { SCE_NP_BASIC_MESSAGE_MAIN_TYPE_DATA_ATTACHMENT = 0, SCE_NP_BASIC_MESSAGE_MAIN_TYPE_GENERAL = 1, @@ -213,7 +567,7 @@ enum }; // Sub types of messages -enum +enum SceNpBasicMessageSubType : u16 { SCE_NP_BASIC_MESSAGE_DATA_ATTACHMENT_SUBTYPE_ACTION_USE = 0, SCE_NP_BASIC_MESSAGE_GENERAL_SUBTYPE_NONE = 0, @@ -225,15 +579,21 @@ enum }; // Applicable features of messages -enum +#define SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(min) ((((u32)min << 16) | (0 << 15)) & 0xFFFF8000) +enum SceNpBasicMessageFeatures : u32 { SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS = 0x00000001, SCE_NP_BASIC_MESSAGE_FEATURES_BOOTABLE = 0x00000002, SCE_NP_BASIC_MESSAGE_FEATURES_ASSUME_SEND = 0x00000004, + SCE_NP_BASIC_MESSAGE_FEATURES_ALL_FEATURES = + SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS | + SCE_NP_BASIC_MESSAGE_FEATURES_BOOTABLE | + SCE_NP_BASIC_MESSAGE_FEATURES_ASSUME_SEND | + SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(0xffff) }; // Types of messages -enum +enum SceNpBasicMessageInfoType : u32 { SCE_NP_BASIC_MESSAGE_INFO_TYPE_MESSAGE_ATTACHMENT = 0, SCE_NP_BASIC_MESSAGE_INFO_TYPE_MATCHING_INVITATION = 1, @@ -307,6 +667,15 @@ enum SCE_NP_SIGNALING_NETINFO_NPPORT_STATUS_OPEN = 1, }; +// NP Receive message options +enum SceNpBasicMessageRecvOptions : u32 +{ + SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_PRESERVE = 0x00000001, + SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_INCLUDE_BOOTABLE = 0x00000002, + SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ASSUME_LATEST = 0x00000004, + SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ALL_OPTIONS = 0x00000007 // sum of all other options +}; + // Constants for common NP functions and structures enum { @@ -325,6 +694,13 @@ enum SCE_NP_COMMUNICATION_PASSPHRASE_SIZE = SCE_NET_NP_COMMUNICATION_PASSPHRASE_SIZE, }; +enum SceNpAvatarSizeType +{ + SCE_NP_AVATAR_SIZE_LARGE, + SCE_NP_AVATAR_SIZE_MIDDLE, + SCE_NP_AVATAR_SIZE_SMALL +}; + // Constants for basic NP functions and structures enum { @@ -357,10 +733,10 @@ enum // Constants for custom menu functions and structures enum { - SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX = 21, - SCE_NP_CUSTOM_MENU_ACTION_ITEMS_MAX = 7, + SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX = 21, + SCE_NP_CUSTOM_MENU_ACTION_ITEMS_MAX = 7, SCE_NP_CUSTOM_MENU_ACTION_ITEMS_TOTAL_MAX = 16, - SCE_NP_CUSTOM_MENU_EXCEPTION_ITEMS_MAX = 256, + SCE_NP_CUSTOM_MENU_EXCEPTION_ITEMS_MAX = 256, }; // Constants for manager functions and structures @@ -375,14 +751,30 @@ enum // Constants for ranking (score) functions and structures enum { - SCE_NP_SCORE_COMMENT_MAXLEN = 63, - SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN = 255, - SCE_NP_SCORE_SANITIZE_COMMENT_MAXLEN = 255, - SCE_NP_SCORE_GAMEINFO_SIZE = 64, - SCE_NP_SCORE_MAX_CTX_NUM = 32, - SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS = 100, - SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS = 101, - SCE_NP_SCORE_MAX_CLAN_NUM_PER_TRANS = 101, + SCE_NP_SCORE_MAX_CTX_NUM = 32, + SCE_NP_SCORE_COMMENT_MAXLEN = 63, + SCE_NP_SCORE_GAMEDATA_ID_LEN = 63, + SCE_NP_SCORE_GAMEINFO_SIZE = 64, + SCE_NP_SCORE_PASSPHRASE_SIZE = 128, + SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN = 255, + SCE_NP_SCORE_SANITIZE_COMMENT_MAXLEN = 255, + SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS = 100, + SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS = 101, + SCE_NP_SCORE_MAX_CLAN_NUM_PER_TRANS = 101, + SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM = 100, + SCE_NP_SCORE_VARIABLE_SIZE_GAMEINFO_MAXSIZE = 189, +}; + +enum +{ + SCE_NP_SCORE_NORMAL_UPDATE = 0, + SCE_NP_SCORE_FORCE_UPDATE = 1 +}; + +enum +{ + SCE_NP_SCORE_DESCENDING_ORDER = 0, + SCE_NP_SCORE_ASCENDING_ORDER = 1 }; // Constants for signaling functions and structures @@ -391,6 +783,38 @@ enum SCE_NP_SIGNALING_CTX_MAX = 8, }; +enum : SceNpPlatformType +{ + SCE_NP_PLATFORM_TYPE_NONE = 0, + SCE_NP_PLATFORM_TYPE_PS3 = 1, + SCE_NP_PLATFORM_TYPE_VITA = 2 +}; + +enum +{ + SCE_NP_MATCHING_GUI_EVENT_CREATE_ROOM = 0x0001, + SCE_NP_MATCHING_GUI_EVENT_JOIN_ROOM = 0x0002, + SCE_NP_MATCHING_GUI_EVENT_RESERVED2 = 0x0003, + SCE_NP_MATCHING_GUI_EVENT_SEARCH_JOIN = 0x0004, + SCE_NP_MATCHING_GUI_EVENT_QUICK_MATCH = 0x0005, + SCE_NP_MATCHING_GUI_EVENT_SEND_INVITATION = 0x0006, + SCE_NP_MATCHING_GUI_EVENT_ACCEPT_INVITATION = 0x0007, + SCE_NP_MATCHING_GUI_EVENT_COMMON_LOAD = 0x0008, + SCE_NP_MATCHING_GUI_EVENT_COMMON_UNLOAD = 0x0009, + SCE_NP_MATCHING_GUI_EVENT_RESERVED3 = 0x000a, + SCE_NP_MATCHING_GUI_EVENT_GET_ROOM_LIST_LIMIT = 0x000b +}; + +struct SceNpDrmKey +{ + u8 keydata[16]; +}; + +struct SceNpDrmOpenArg +{ + be_t flag; +}; + // NP communication ID structure struct SceNpCommunicationId { @@ -508,7 +932,7 @@ struct SceNpBasicExtendedAttachmentData SceNpBasicAttachmentData data; be_t userAction; b8 markedAsUsed; - //be_t reserved[3]; + u8 reserved[3]; }; // Message structure @@ -676,10 +1100,11 @@ union SceNpSignalingConnectionInfo be_t rtt; be_t bandwidth; SceNpId npId; - struct address { + struct + { be_t addr; // in_addr be_t port; // in_port_t - }; + } address; be_t packet_loss; }; @@ -695,5 +1120,181 @@ struct SceNpSignalingNetInfo be_t npport; }; -// NP signaling callback function -typedef void(*SceNpSignalingHandler)(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, u32 arg_addr); +struct SceNpCustomMenuAction +{ + be_t options; + char name[SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX]; + be_t mask; +}; + +struct SceNpCustomMenu +{ + be_t options; + vm::bptr actions; + be_t numActions; +}; + +struct SceNpCustomMenuIndexArray +{ + be_t index_bits[SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT]; +}; + +struct SceNpCustomMenuActionExceptions +{ + be_t options; + SceNpId npid; + SceNpCustomMenuIndexArray actions; + u8 reserved[4]; +}; + +struct SceNpCommerceProductCategory +{ + be_t version; + vm::bcptr data; + be_t dataSize; + be_t dval; + u8 reserved[16]; +}; + +struct SceNpCommerceProductSkuInfo +{ + vm::bptr pc; + vm::bcptr data; + u8 reserved[8]; +}; + +struct SceNpCommerceCategoryInfo +{ + vm::bptr pc; + vm::bcptr data; + u8 reserved[8]; +}; + +struct SceNpCommerceCurrencyInfo +{ + vm::bptr pc; + vm::bcptr data; + u8 reserved[8]; +}; + +struct SceNpCommercePrice +{ + be_t integer; + be_t fractional; +}; + +struct SceNpTicketVersion +{ + be_t major; + be_t minor; +}; + +union SceNpTicketParam +{ + be_t i32; + be_t i64; + be_t u32; + be_t u64; + SceNpDate date; + u8 data[SCE_NP_TICKET_PARAM_DATA_LEN]; +}; + +struct SceNpEntitlement +{ + SceNpEntitlementId id; + be_t created_date; + be_t expire_date; + be_t type; + be_t remaining_count; + be_t consumed_count; + u8 padding[4]; +}; + +struct SceNpLobbyId +{ + u8 opt[28]; + u8 reserved[8]; +}; + +struct SceNpRoomId +{ + u8 opt[28]; + u8 reserved[8]; +}; + +struct SceNpMatchingAttr +{ + vm::bptr next; + be_t type; + be_t id; + union + { + be_t num; + struct + { + vm::bptr ptr; + be_t size; + } data; + } value; +}; + +struct SceNpMatchingSearchCondition +{ + vm::bptr next; + be_t target_attr_type; + be_t target_attr_id; + be_t comp_op; + be_t comp_type; + SceNpMatchingAttr compared; +}; + +struct SceNpMatchingReqRange +{ + be_t start; + be_t max; +}; + +struct SceNpScoreVariableSizeGameInfo +{ + be_t infoSize; + u8 data[SCE_NP_SCORE_VARIABLE_SIZE_GAMEINFO_MAXSIZE]; + u8 pad[3]; +}; + +struct SceNpScoreRecordOptParam +{ + be_t size; + vm::bptr vsInfo; + vm::bptr reserved; +}; + +// NP callback functions +using SceNpCustomMenuEventHandler = s32(s32 retCode, u32 index, vm::cptr npid, SceNpCustomMenuSelectedType type, vm::ptr arg); +using SceNpBasicEventHandler = s32(s32 event, s32 retCode, u32 reqId, vm::ptr arg); +using SceNpCommerceHandler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr arg); +using SceNpSignalingHandler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, u32 arg_addr); +using SceNpFriendlistResultHandler = s32(s32 retCode, vm::ptr arg); +using SceNpMatchingHandler = void(u32 ctx_id, u32 req_id, s32 event, s32 error_code, vm::ptr arg); +using SceNpMatchingGUIHandler = void(u32 ctx_id, s32 event, s32 error_code, vm::ptr arg); +using SceNpProfileResultHandler = s32(s32 result, vm::ptr arg); + +using SceNpManagerSubSigninCallback = void(s32 result, vm::ptr npId, vm::ptr cb_arg); + +// fxm objects + +struct sce_np_manager +{ + std::atomic is_initialized = false; +}; + +struct sce_np_lookup_manager +{ + std::atomic is_initialized = false; +}; + +struct sce_np_score_manager +{ + std::atomic is_initialized = false; +}; + +extern s32 g_psn_connection_status; diff --git a/rpcs3/Emu/Cell/Modules/sceNp2.cpp b/rpcs3/Emu/Cell/Modules/sceNp2.cpp index 441e461b1c..dc8bd08033 100644 --- a/rpcs3/Emu/Cell/Modules/sceNp2.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNp2.cpp @@ -1,511 +1,1390 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" +#include "Emu/IdManager.h" #include "sceNp.h" #include "sceNp2.h" LOG_CHANNEL(sceNp2); -s32 sceNp2Init(u32 poolsize, vm::ptr poolptr) +template<> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](auto error) + { + switch (error) + { + STR_CASE(SCE_NP_MATCHING2_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_MAX); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_ALREADY_EXISTS); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_ALREADY_STARTED); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_NOT_STARTED); + STR_CASE(SCE_NP_MATCHING2_ERROR_SERVER_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_CONTEXT_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_SERVER_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_WORLD_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_LOBBY_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_ROOM_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_MEMBER_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_ATTRIBUTE_ID); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_CASTTYPE); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_SORT_METHOD); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_MAX_SLOT); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_MATCHING_SPACE); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_BLOCK_KICK_FLAG); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_MESSAGE_TARGET); + STR_CASE(SCE_NP_MATCHING2_ERROR_RANGE_FILTER_MAX); + STR_CASE(SCE_NP_MATCHING2_ERROR_INSUFFICIENT_BUFFER); + STR_CASE(SCE_NP_MATCHING2_ERROR_DESTINATION_DISAPPEARED); + STR_CASE(SCE_NP_MATCHING2_ERROR_REQUEST_TIMEOUT); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_ALIGNMENT); + STR_CASE(SCE_NP_MATCHING2_ERROR_REQUEST_CB_QUEUE_OVERFLOW); + STR_CASE(SCE_NP_MATCHING2_ERROR_EVENT_CB_QUEUE_OVERFLOW); + STR_CASE(SCE_NP_MATCHING2_ERROR_MSG_CB_QUEUE_OVERFLOW); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONNECTION_CLOSED_BY_SERVER); + STR_CASE(SCE_NP_MATCHING2_ERROR_SSL_VERIFY_FAILED); + STR_CASE(SCE_NP_MATCHING2_ERROR_SSL_HANDSHAKE); + STR_CASE(SCE_NP_MATCHING2_ERROR_SSL_SEND); + STR_CASE(SCE_NP_MATCHING2_ERROR_SSL_RECV); + STR_CASE(SCE_NP_MATCHING2_ERROR_JOINED_SESSION_MAX); + STR_CASE(SCE_NP_MATCHING2_ERROR_ALREADY_JOINED); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_SESSION_TYPE); + STR_CASE(SCE_NP_MATCHING2_ERROR_CLAN_LOBBY_NOT_EXIST); + STR_CASE(SCE_NP_MATCHING2_ERROR_NP_SIGNED_OUT); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_UNAVAILABLE); + STR_CASE(SCE_NP_MATCHING2_ERROR_SERVER_NOT_AVAILABLE); + STR_CASE(SCE_NP_MATCHING2_ERROR_NOT_ALLOWED); + STR_CASE(SCE_NP_MATCHING2_ERROR_ABORTED); + STR_CASE(SCE_NP_MATCHING2_ERROR_REQUEST_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_SESSION_DESTROYED); + STR_CASE(SCE_NP_MATCHING2_ERROR_CONTEXT_STOPPED); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_REQUEST_PARAMETER); + STR_CASE(SCE_NP_MATCHING2_ERROR_NOT_NP_SIGN_IN); + STR_CASE(SCE_NP_MATCHING2_ERROR_ROOM_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_ROOM_MEMBER_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_LOBBY_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_LOBBY_MEMBER_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_EVENT_DATA_NOT_FOUND); + STR_CASE(SCE_NP_MATCHING2_ERROR_KEEPALIVE_TIMEOUT); + STR_CASE(SCE_NP_MATCHING2_ERROR_TIMEOUT_TOO_SHORT); + STR_CASE(SCE_NP_MATCHING2_ERROR_TIMEDOUT); + STR_CASE(SCE_NP_MATCHING2_ERROR_CREATE_HEAP); + STR_CASE(SCE_NP_MATCHING2_ERROR_INVALID_ATTRIBUTE_SIZE); + STR_CASE(SCE_NP_MATCHING2_ERROR_CANNOT_ABORT); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_NO_DNS_SERVER); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_INVALID_PACKET); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_TIMEOUT); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_NO_RECORD); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_RES_PACKET_FORMAT); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_RES_SERVER_FAILURE); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_NO_HOST); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_RES_NOT_IMPLEMENTED); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_RES_SERVER_REFUSED); + STR_CASE(SCE_NP_MATCHING2_RESOLVER_ERROR_RESP_TRUNCATED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_BAD_REQUEST); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_SERVICE_UNAVAILABLE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_BUSY); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_END_OF_SERVICE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_INTERNAL_SERVER_ERROR); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_PLAYER_BANNED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_FORBIDDEN); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_BLOCKED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_UNSUPPORTED_NP_ENV); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_INVALID_TICKET); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_INVALID_SIGNATURE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_EXPIRED_TICKET); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_ENTITLEMENT_REQUIRED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_CONTEXT); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_CLOSED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_TITLE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_WORLD); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_LOBBY); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_LOBBY_INSTANCE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM_INSTANCE); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_PASSWORD_MISMATCH); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_LOBBY_FULL); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_ROOM_FULL); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_GROUP_FULL); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_USER); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_TITLE_PASSPHRASE_MISMATCH); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_LOBBY); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_ROOM); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_JOIN_GROUP_LABEL); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_GROUP); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NO_PASSWORD); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_MAX_OVER_SLOT_GROUP); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_MAX_OVER_PASSWORD_MASK); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_GROUP_LABEL); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_REQUEST_OVERFLOW); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_ALREADY_JOINED); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_NAT_TYPE_MISMATCH); + STR_CASE(SCE_NP_MATCHING2_SERVER_ERROR_ROOM_INCONSISTENCY); + // STR_CASE(SCE_NP_MATCHING2_NET_ERRNO_BASE); + // STR_CASE(SCE_NP_MATCHING2_NET_H_ERRNO_BASE); + } + + return unknown; + }); +} + +template<> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](auto error) + { + switch (error) + { + STR_CASE(SCE_NP_OAUTH_ERROR_UNKNOWN); + STR_CASE(SCE_NP_OAUTH_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_OAUTH_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_OAUTH_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_OAUTH_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_OAUTH_ERROR_OUT_OF_BUFFER); + STR_CASE(SCE_NP_OAUTH_ERROR_BAD_RESPONSE); + STR_CASE(SCE_NP_OAUTH_ERROR_ABORTED); + STR_CASE(SCE_NP_OAUTH_ERROR_SIGNED_OUT); + STR_CASE(SCE_NP_OAUTH_ERROR_REQUEST_NOT_FOUND); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_CN_CHECK); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_UNKNOWN_CA); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_AFTER_CHECK); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_BEFORE_CHECK); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_INVALID_CERT); + STR_CASE(SCE_NP_OAUTH_ERROR_SSL_ERR_INTERNAL); + STR_CASE(SCE_NP_OAUTH_ERROR_REQUEST_MAX); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_BANNED_CONSOLE); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_INVALID_LOGIN); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_INACTIVE_ACCOUNT); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_ACCOUNT); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_DEVICE); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_PASSWORD_EXPIRED); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED_FOR_SUBACCOUNT); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_BANNED_ACCOUNT); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_SERVICE_END); + STR_CASE(SCE_NP_OAUTH_SERVER_ERROR_SERVICE_UNAVAILABLE); + } + + return unknown; + }); +} + +error_code sceNp2Init(u64 poolsize, vm::ptr poolptr) { sceNp2.warning("sceNp2Init(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr); - if (poolsize == 0) + const auto manager = g_fxo->get(); + + if (manager->is_initialized) + { + return SCE_NP_ERROR_ALREADY_INITIALIZED; + } + + if (poolsize == 0 || !poolptr) { return SCE_NP_ERROR_INVALID_ARGUMENT; } - else if (poolsize < 128 * 1024) + + if (poolsize < SCE_NP_MIN_POOLSIZE) { return SCE_NP_ERROR_INSUFFICIENT_BUFFER; } - if (!poolptr) + manager->is_initialized = true; + + return CELL_OK; +} + +error_code sceNpMatching2Init(u32 stackSize, s32 priority) +{ + sceNp2.todo("sceNpMatching2Init(stackSize=0x%x, priority=%d)", stackSize, priority); + + if (!g_fxo->get()->is_initialized) { - return SCE_NP_ERROR_INVALID_ARGUMENT; + return SCE_NP_ERROR_NOT_INITIALIZED; } - return CELL_OK; -} + const auto matching_manager = g_fxo->get(); -s32 sceNpMatching2Init(u32 poolsize, s32 priority) -{ - sceNp2.todo("sceNpMatching2Init(poolsize=0x%x, priority=%d)", poolsize, priority); + if (matching_manager->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED; + } + + matching_manager->is_initialized = true; return CELL_OK; } -s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr param) +error_code sceNpMatching2Init2(u64 stackSize, s32 priority, vm::ptr param) { - sceNp2.todo("sceNpMatching2Init2(poolsize=0x%x, priority=%d, param=*0x%x)", poolsize, priority, param); + sceNp2.todo("sceNpMatching2Init2(stackSize=0x%x, priority=%d, param=*0x%x)", stackSize, priority, param); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + const auto matching_2_manager = g_fxo->get(); + + if (matching_2_manager->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED; + } // TODO: // 1. Create an internal thread // 2. Create heap area to be used by the NP matching 2 utility // 3. Set maximum lengths for the event data queues in the system + matching_2_manager->is_initialized = true; + return CELL_OK; } -s32 sceNp2Term() +error_code sceNp2Term() { sceNp2.warning("sceNp2Term()"); + const auto manager = g_fxo->get(); + + if (!manager->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + manager->is_initialized = false; + return CELL_OK; } -s32 sceNpMatching2Term(ppu_thread& ppu) +error_code sceNpMatching2Term(ppu_thread& ppu) { sceNp2.warning("sceNpMatching2Term()"); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + const auto matching_manager = g_fxo->get(); + + if (!matching_manager->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + matching_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpMatching2Term2() +error_code sceNpMatching2Term2() { sceNp2.warning("sceNpMatching2Term2()"); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + const auto matching_2_manager = g_fxo->get(); + + if (!matching_2_manager->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + matching_2_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpMatching2DestroyContext() +error_code sceNpMatching2DestroyContext(SceNpMatching2ContextId ctxId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2DestroyContext(ctxId=%d)", ctxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2LeaveLobby() +error_code sceNpMatching2LeaveLobby(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2LeaveLobby(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2RegisterLobbyMessageCallback() +error_code sceNpMatching2RegisterLobbyMessageCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterLobbyMessageCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetWorldInfoList() +error_code sceNpMatching2GetWorldInfoList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetWorldInfoList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2RegisterLobbyEventCallback() +error_code sceNpMatching2RegisterLobbyEventCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterLobbyEventCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetLobbyMemberDataInternalList() +error_code sceNpMatching2GetLobbyMemberDataInternalList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetLobbyMemberDataInternalList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SearchRoom() +error_code sceNpMatching2SearchRoom(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SearchRoom(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetConnectionStatus() +error_code sceNpMatching2SignalingGetConnectionStatus(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId memberId, vm::ptr connStatus, vm::ptr peerAddr, vm::ptr peerPort) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetConnectionStatus(ctxId=%d, roomId=%d, memberId=%d, connStatus=*0x%x, peerAddr=*0x%x, peerPort=*0x%x)", ctxId, roomId, memberId, connStatus, peerAddr, peerPort); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SetUserInfo() +error_code sceNpMatching2SetUserInfo(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetUserInfo(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetClanLobbyId() +error_code sceNpMatching2GetClanLobbyId(SceNpMatching2ContextId ctxId, SceNpClanId clanId, vm::ptr lobbyId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetClanLobbyId(ctxId=%d, clanId=%d, lobbyId=*0x%x)", ctxId, clanId, lobbyId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetLobbyMemberDataInternal() +error_code sceNpMatching2GetLobbyMemberDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetLobbyMemberDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2ContextStart() +error_code sceNpMatching2ContextStart(SceNpMatching2ContextId ctxId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2ContextStart(ctxId=%d)", ctxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2CreateServerContext() +error_code sceNpMatching2CreateServerContext(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2CreateServerContext(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetMemoryInfo() +error_code sceNpMatching2GetMemoryInfo(vm::ptr memInfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetMemoryInfo(memInfo=*0x%x)", memInfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2LeaveRoom() +error_code sceNpMatching2LeaveRoom(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2LeaveRoom(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SetRoomDataExternal() +error_code sceNpMatching2SetRoomDataExternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetRoomDataExternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetConnectionInfo() +error_code sceNpMatching2SignalingGetConnectionInfo(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId memberId, s32 code, vm::ptr connInfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetConnectionInfo(ctxId=%d, roomId=%d, memberId=%d, code=%d, connInfo=*0x%x)", ctxId, roomId, memberId, code, connInfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SendRoomMessage() +error_code sceNpMatching2SendRoomMessage(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SendRoomMessage(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2JoinLobby() +error_code sceNpMatching2JoinLobby(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2JoinLobby(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomMemberDataExternalList() +error_code sceNpMatching2GetRoomMemberDataExternalList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomMemberDataExternalList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2AbortRequest() +error_code sceNpMatching2AbortRequest(SceNpMatching2ContextId ctxId, SceNpMatching2RequestId reqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2AbortRequest(ctxId=%d, reqId=%d)", ctxId, reqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetServerInfo() +error_code sceNpMatching2GetServerInfo(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetServerInfo(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetEventData() +error_code sceNpMatching2GetEventData(SceNpMatching2ContextId ctxId, SceNpMatching2EventKey eventKey, vm::ptr buf, u64 bufLen) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetEventData(ctxId=%d, eventKey=%d, buf=*0x%x, bufLen=%d)", ctxId, eventKey, buf, bufLen); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!buf) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomSlotInfoLocal() +error_code sceNpMatching2GetRoomSlotInfoLocal(SceNpMatching2ContextId ctxId, const SceNpMatching2RoomId roomId, vm::ptr roomSlotInfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomSlotInfoLocal(ctxId=%d, roomId=%d, roomSlotInfo=*0x%x)", ctxId, roomId, roomSlotInfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SendLobbyChatMessage() +error_code sceNpMatching2SendLobbyChatMessage(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SendLobbyChatMessage(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2AbortContextStart() +error_code sceNpMatching2AbortContextStart(SceNpMatching2ContextId ctxId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2AbortContextStart(ctxId=%d)", ctxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomMemberIdListLocal() +error_code sceNpMatching2GetRoomMemberIdListLocal(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, s32 sortMethod, vm::ptr memberId, u32 memberIdNum) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomMemberIdListLocal(ctxId=%d, roomId=%d, sortMethod=%d, memberId=*0x%x, memberIdNum=%d)", ctxId, roomId, sortMethod, memberId, memberIdNum); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2JoinRoom() +error_code sceNpMatching2JoinRoom(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2JoinRoom(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomMemberDataInternalLocal() +error_code sceNpMatching2GetRoomMemberDataInternalLocal(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId memberId, + vm::cptr attrId, u32 attrIdNum, vm::ptr member, vm::ptr buf, u64 bufLen) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomMemberDataInternalLocal(ctxId=%d, roomId=%d, memberId=%d, attrId=*0x%x, attrIdNum=%d, member=*0x%x, buf=*0x%x, bufLen=%d)", + ctxId, roomId, memberId, attrId, attrIdNum, member, buf, bufLen); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetCbQueueInfo() +error_code sceNpMatching2GetCbQueueInfo(SceNpMatching2ContextId ctxId, vm::ptr queueInfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetCbQueueInfo(ctxId=%d, queueInfo=*0x%x)", ctxId, queueInfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2KickoutRoomMember() +error_code sceNpMatching2KickoutRoomMember(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2KickoutRoomMember(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2ContextStartAsync() +error_code sceNpMatching2ContextStartAsync(SceNpMatching2ContextId ctxId, u32 timeout) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2ContextStartAsync(ctxId=%d, timeout=%d)", ctxId, timeout); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SetSignalingOptParam() +error_code sceNpMatching2SetSignalingOptParam(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetSignalingOptParam(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2RegisterContextCallback() +error_code sceNpMatching2RegisterContextCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterContextCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SendRoomChatMessage() +error_code sceNpMatching2SendRoomChatMessage(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SendRoomChatMessage(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SetRoomDataInternal() +error_code sceNpMatching2SetRoomDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetRoomDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomDataInternal() +error_code sceNpMatching2GetRoomDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetPingInfo() +error_code sceNpMatching2SignalingGetPingInfo(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetPingInfo(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetServerIdListLocal() +error_code sceNpMatching2GetServerIdListLocal(SceNpMatching2ContextId ctxId, vm::ptr serverId, u32 serverIdNum) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetServerIdListLocal(ctxId=%d, serverId=*0x%x, serverIdNum=%d)", ctxId, serverId, serverIdNum); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpUtilBuildCdnUrl() +error_code sceNpUtilBuildCdnUrl(vm::cptr url, vm::ptr buf, u64 bufSize, vm::ptr required, vm::ptr option) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpUtilBuildCdnUrl(url=%s, buf=*0x%x, bufSize=%d, required=*0x%x, option=*0x%x)", url, buf, bufSize, required, option); + + if (!url || option) // option check at least until fw 4.71 + { + // TODO: check url for '?' + return SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; + } + + //if (offline) + //{ + // return SCE_NP_ERROR_OFFLINE; + //} + return CELL_OK; } -s32 sceNpMatching2GrantRoomOwner() +error_code sceNpMatching2GrantRoomOwner(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GrantRoomOwner(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2CreateContext() +error_code sceNpMatching2CreateContext(vm::cptr npId, vm::cptr commId, vm::cptr passPhrase, vm::ptr ctxId, s32 option) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2CreateContext(npId=*0x%x, commId=*0x%x, passPhrase=*0x%x, ctxId=*0x%x, option=%d)", npId, commId, passPhrase, ctxId, option); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!npId || !commId || !passPhrase || !ctxId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetSignalingOptParamLocal() +error_code sceNpMatching2GetSignalingOptParamLocal(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, vm::ptr signalingOptParam) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetSignalingOptParamLocal(ctxId=%d, roomId=%d, signalingOptParam=*0x%x)", ctxId, roomId, signalingOptParam); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2RegisterSignalingCallback() +error_code sceNpMatching2RegisterSignalingCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterSignalingCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2ClearEventData() +error_code sceNpMatching2ClearEventData(SceNpMatching2ContextId ctxId, SceNpMatching2EventKey eventKey) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2ClearEventData(ctxId=%d, eventKey=%d)", ctxId, eventKey); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetUserInfoList() +error_code sceNpMatching2GetUserInfoList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetUserInfoList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomMemberDataInternal() +error_code sceNpMatching2GetRoomMemberDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomMemberDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SetRoomMemberDataInternal() +error_code sceNpMatching2SetRoomMemberDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetRoomMemberDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2JoinProhibitiveRoom() +error_code sceNpMatching2JoinProhibitiveRoom(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2JoinProhibitiveRoom(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingSetCtxOpt() +error_code sceNpMatching2SignalingSetCtxOpt(SceNpMatching2ContextId ctxId, s32 optname, s32 optval) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingSetCtxOpt(ctxId=%d, optname=%d, optval=%d)", ctxId, optname, optval); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2DeleteServerContext() +error_code sceNpMatching2DeleteServerContext(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2DeleteServerContext(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SetDefaultRequestOptParam() +error_code sceNpMatching2SetDefaultRequestOptParam(SceNpMatching2ContextId ctxId, vm::cptr optParam) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetDefaultRequestOptParam(ctxId=%d, optParam=*0x%x)", ctxId, optParam); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!optParam) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2RegisterRoomEventCallback() +error_code sceNpMatching2RegisterRoomEventCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterRoomEventCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomPasswordLocal() +error_code sceNpMatching2GetRoomPasswordLocal(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, vm::ptr withPassword, vm::ptr roomPassword) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomPasswordLocal(ctxId=%d, roomId=%d, withPassword=*0x%x, roomPassword=*0x%x)", ctxId, roomId, withPassword, roomPassword); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetRoomDataExternalList() +error_code sceNpMatching2GetRoomDataExternalList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetRoomDataExternalList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2CreateJoinRoom() +error_code sceNpMatching2CreateJoinRoom(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2CreateJoinRoom(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetCtxOpt() +error_code sceNpMatching2SignalingGetCtxOpt(SceNpMatching2ContextId ctxId, s32 optname, vm::ptr optval) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetCtxOpt(ctxId=%d, optname=%d, optval=*0x%x)", ctxId, optname, optval); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2GetLobbyInfoList() +error_code sceNpMatching2GetLobbyInfoList(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetLobbyInfoList(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2GetLobbyMemberIdListLocal() +error_code sceNpMatching2GetLobbyMemberIdListLocal(SceNpMatching2ContextId ctxId, SceNpMatching2LobbyId lobbyId, vm::ptr memberId, u32 memberIdNum, vm::ptr me) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2GetLobbyMemberIdListLocal(ctxId=%d, lobbyId=%d, memberId=*0x%x, memberIdNum=%d, me=*0x%x)", ctxId, lobbyId, memberId, memberIdNum, me); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SendLobbyInvitation() +error_code sceNpMatching2SendLobbyInvitation(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SendLobbyInvitation(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2ContextStop() +error_code sceNpMatching2ContextStop(SceNpMatching2ContextId ctxId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2ContextStop(ctxId=%d)", ctxId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SetLobbyMemberDataInternal() +error_code sceNpMatching2SetLobbyMemberDataInternal(SceNpMatching2ContextId ctxId, vm::cptr reqParam, vm::cptr optParam, vm::ptr assignedReqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SetLobbyMemberDataInternal(ctxId=%d, reqParam=*0x%x, optParam=*0x%x, assignedReqId=*0x%x)", ctxId, reqParam, optParam, assignedReqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqParam || !optParam || !assignedReqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2RegisterRoomMessageCallback() +error_code sceNpMatching2RegisterRoomMessageCallback(SceNpMatching2ContextId ctxId, vm::ptr cbFunc, vm::ptr cbFuncArg) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2RegisterRoomMessageCallback(ctxId=%d, cbFunc=*0x%x, cbFuncArg=*0x%x)", ctxId, cbFunc, cbFuncArg); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SignalingCancelPeerNetInfo() +error_code sceNpMatching2SignalingCancelPeerNetInfo(SceNpMatching2ContextId ctxId, SceNpMatching2SignalingRequestId reqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingCancelPeerNetInfo(ctxId=%d, reqId=%d)", ctxId, reqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetLocalNetInfo() +error_code sceNpMatching2SignalingGetLocalNetInfo(vm::ptr netinfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetLocalNetInfo(netinfo=*0x%x)", netinfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!netinfo) + { + // TODO: check netinfo->size + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetPeerNetInfo() +error_code sceNpMatching2SignalingGetPeerNetInfo(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId roomMemberId, vm::ptr reqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetPeerNetInfo(ctxId=%d, roomId=%d, roomMemberId=%d, reqId=*0x%x)", ctxId, roomId, roomMemberId, reqId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!reqId) + { + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpMatching2SignalingGetPeerNetInfoResult() +error_code sceNpMatching2SignalingGetPeerNetInfoResult(SceNpMatching2ContextId ctxId, SceNpMatching2SignalingRequestId reqId, vm::ptr netinfo) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpMatching2SignalingGetPeerNetInfoResult(ctxId=%d, reqId=%d, netinfo=*0x%x)", ctxId, reqId, netinfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED; + } + + if (!netinfo) + { + // TODO: check netinfo->size + return SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpAuthOAuthInit() +error_code sceNpAuthOAuthInit() { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthOAuthInit()"); + + const auto manager = g_fxo->get(); + + if (manager->is_initialized) + { + return SCE_NP_OAUTH_ERROR_ALREADY_INITIALIZED; + } + + manager->is_initialized = true; + return CELL_OK; } -s32 sceNpAuthOAuthTerm() +error_code sceNpAuthOAuthTerm() { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthOAuthTerm()"); + + const auto manager = g_fxo->get(); + + // TODO: check if this might throw SCE_NP_OAUTH_ERROR_NOT_INITIALIZED + manager->is_initialized = false; + return CELL_OK; } -s32 sceNpAuthCreateOAuthRequest() +error_code sceNpAuthCreateOAuthRequest() { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthCreateOAuthRequest()"); + + if(!g_fxo->get()->is_initialized) + { + return SCE_NP_OAUTH_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpAuthDeleteOAuthRequest() +error_code sceNpAuthDeleteOAuthRequest(SceNpAuthOAuthRequestId reqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthDeleteOAuthRequest(reqId=%d)"); + + if(!g_fxo->get()->is_initialized) + { + return SCE_NP_OAUTH_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpAuthAbortOAuthRequest() +error_code sceNpAuthAbortOAuthRequest(SceNpAuthOAuthRequestId reqId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthAbortOAuthRequest(reqId=%d)"); + + if(!g_fxo->get()->is_initialized) + { + return SCE_NP_OAUTH_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpAuthGetAuthorizationCode() +error_code sceNpAuthGetAuthorizationCode(SceNpAuthOAuthRequestId reqId, vm::cptr param, vm::ptr authCode, vm::ptr issuerId) { - UNIMPLEMENTED_FUNC(sceNp2); + sceNp2.todo("sceNpAuthGetAuthorizationCode(reqId=%d, param=*0x%x, authCode=*0x%x, issuerId=%d)", reqId, param, authCode, issuerId); + + if(!g_fxo->get()->is_initialized) + { + return SCE_NP_OAUTH_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpAuthGetAuthorizationCode2() +error_code sceNpAuthGetAuthorizationCode2() { UNIMPLEMENTED_FUNC(sceNp2); return CELL_OK; diff --git a/rpcs3/Emu/Cell/Modules/sceNp2.h b/rpcs3/Emu/Cell/Modules/sceNp2.h index 84e0e7648f..b19e18b09e 100644 --- a/rpcs3/Emu/Cell/Modules/sceNp2.h +++ b/rpcs3/Emu/Cell/Modules/sceNp2.h @@ -4,8 +4,10 @@ #include "Emu/Memory/vm_ptr.h" +#include + // Error codes -enum +enum SceNpMatching2Error : u32 { // NP Matching 2 Utility SCE_NP_MATCHING2_ERROR_OUT_OF_MEMORY = 0x80022301, @@ -463,6 +465,11 @@ enum SCE_NP_MATCHING2_CONTEXT_EVENT_Stop = 0x6f03, }; +enum +{ + SCE_NP_MIN_POOLSIZE = 128 * 1024 +}; + typedef u16 SceNpMatching2ServerId; typedef u32 SceNpMatching2WorldId; typedef u16 SceNpMatching2WorldNumber; @@ -491,6 +498,7 @@ typedef u64 SceNpMatching2RoomPasswordSlotMask; typedef u64 SceNpMatching2RoomJoinedSlotMask; typedef u16 SceNpMatching2Event; typedef u32 SceNpMatching2EventKey; +typedef u32 SceNpMatching2SignalingRequestId; typedef SceNpCommunicationPassphrase SceNpMatching2TitlePassphrase; // Request callback function @@ -1507,3 +1515,94 @@ struct SceNpMatching2CbQueueInfo be_t maxSessionMsgCbQueueLen; u8 reserved[12]; }; + +union SceNpMatching2SignalingNetInfo // TODO check values +{ + be_t size; + be_t localAddr; + be_t mappedAddr; + be_t natStatus; +}; + +// NP OAuth Errors +enum SceNpOauthError : u32 +{ + SCE_NP_OAUTH_ERROR_UNKNOWN = 0x80025f01, + SCE_NP_OAUTH_ERROR_ALREADY_INITIALIZED = 0x80025f02, + SCE_NP_OAUTH_ERROR_NOT_INITIALIZED = 0x80025f03, + SCE_NP_OAUTH_ERROR_INVALID_ARGUMENT = 0x80025f04, + SCE_NP_OAUTH_ERROR_OUT_OF_MEMORY = 0x80025f05, + SCE_NP_OAUTH_ERROR_OUT_OF_BUFFER = 0x80025f06, + SCE_NP_OAUTH_ERROR_BAD_RESPONSE = 0x80025f07, + SCE_NP_OAUTH_ERROR_ABORTED = 0x80025f08, + SCE_NP_OAUTH_ERROR_SIGNED_OUT = 0x80025f09, + SCE_NP_OAUTH_ERROR_REQUEST_NOT_FOUND = 0x80025f0a, + SCE_NP_OAUTH_ERROR_SSL_ERR_CN_CHECK = 0x80025f0b, + SCE_NP_OAUTH_ERROR_SSL_ERR_UNKNOWN_CA = 0x80025f0c, + SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_AFTER_CHECK = 0x80025f0d, + SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_BEFORE_CHECK = 0x80025f0e, + SCE_NP_OAUTH_ERROR_SSL_ERR_INVALID_CERT = 0x80025f0f, + SCE_NP_OAUTH_ERROR_SSL_ERR_INTERNAL = 0x80025f10, + SCE_NP_OAUTH_ERROR_REQUEST_MAX = 0x80025f11, + + SCE_NP_OAUTH_SERVER_ERROR_BANNED_CONSOLE = 0x80025d14, + SCE_NP_OAUTH_SERVER_ERROR_INVALID_LOGIN = 0x82e00014, + SCE_NP_OAUTH_SERVER_ERROR_INACTIVE_ACCOUNT = 0x82e0001b, + SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_ACCOUNT = 0x82e0001c, + SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_DEVICE = 0x82e0001d, + SCE_NP_OAUTH_SERVER_ERROR_PASSWORD_EXPIRED = 0x82e00064, + SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED = 0x82e00067, + SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED_FOR_SUBACCOUNT = 0x82e01042, + SCE_NP_OAUTH_SERVER_ERROR_BANNED_ACCOUNT = 0x82e01050, + SCE_NP_OAUTH_SERVER_ERROR_SERVICE_END = 0x82e1019a, + SCE_NP_OAUTH_SERVER_ERROR_SERVICE_UNAVAILABLE = 0x82e101f7, +}; + +typedef s32 SceNpAuthOAuthRequestId; + +enum +{ + SCE_NP_AUTHORIZATION_CODE_MAX_LEN = 128, + SCE_NP_CLIENT_ID_MAX_LEN = 128, +}; + +struct SceNpClientId +{ + char id[SCE_NP_CLIENT_ID_MAX_LEN + 1]; + u8 padding[7]; +}; + +struct SceNpAuthorizationCode +{ + char code[SCE_NP_AUTHORIZATION_CODE_MAX_LEN + 1]; + u8 padding[7]; +}; + +struct SceNpAuthGetAuthorizationCodeParameter +{ + be_t size; + vm::bcptr pClientId; + vm::bcptr pScope; +}; + +// fxm objects + +struct sce_np_2_manager +{ + std::atomic is_initialized = false; +}; + +struct sce_np_2_matching_manager +{ + std::atomic is_initialized = false; +}; + +struct sce_np_2_matching_2_manager +{ + std::atomic is_initialized = false; +}; + +struct sce_np_oauth_2_manager +{ + std::atomic is_initialized = false; +}; diff --git a/rpcs3/Emu/Cell/Modules/sceNpClans.cpp b/rpcs3/Emu/Cell/Modules/sceNpClans.cpp index e3d7daca27..0d60378ef1 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpClans.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNpClans.cpp @@ -1,35 +1,135 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" +#include "Emu/IdManager.h" #include "sceNp.h" #include "sceNpClans.h" LOG_CHANNEL(sceNpClans); -s32 sceNpClansInit(vm::ptr commId, vm::ptr passphrase, vm::ptr pool, vm::ptr poolSize, u32 flags) +template<> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](auto error) + { + switch (error) + { + STR_CASE(SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED); + STR_CASE(SCE_NP_CLANS_ERROR_NOT_INITIALIZED); + STR_CASE(SCE_NP_CLANS_ERROR_NOT_SUPPORTED); + STR_CASE(SCE_NP_CLANS_ERROR_OUT_OF_MEMORY); + STR_CASE(SCE_NP_CLANS_ERROR_INVALID_ARGUMENT); + STR_CASE(SCE_NP_CLANS_ERROR_EXCEEDS_MAX); + STR_CASE(SCE_NP_CLANS_ERROR_BAD_RESPONSE); + STR_CASE(SCE_NP_CLANS_ERROR_BAD_DATA); + STR_CASE(SCE_NP_CLANS_ERROR_BAD_REQUEST); + STR_CASE(SCE_NP_CLANS_ERROR_INVALID_SIGNATURE); + STR_CASE(SCE_NP_CLANS_ERROR_INSUFFICIENT); + STR_CASE(SCE_NP_CLANS_ERROR_INTERNAL_BUFFER); + STR_CASE(SCE_NP_CLANS_ERROR_SERVER_MAINTENANCE); + STR_CASE(SCE_NP_CLANS_ERROR_SERVER_END_OF_SERVICE); + STR_CASE(SCE_NP_CLANS_ERROR_SERVER_BEFORE_START_OF_SERVICE); + STR_CASE(SCE_NP_CLANS_ERROR_ABORTED); + STR_CASE(SCE_NP_CLANS_ERROR_SERVICE_UNAVAILABLE); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_BAD_REQUEST); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_TICKET); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_SIGNATURE); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_TICKET_EXPIRED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_NPID); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_FORBIDDEN); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INTERNAL_SERVER_ERROR); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_BANNED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_BLACKLISTED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_ENVIRONMENT); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_SERVICE); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_MEMBER); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_BEFORE_HOURS); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLOSED_SERVICE); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_PERMISSION_DENIED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_MEMBER_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_JOINED_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_MEMBER_STATUS_INVALID); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_NAME); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_CANNOT_LEAVE); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_ROLE_PRIORITY); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_ANNOUNCEMENT_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_CONFIG_MASTER_NOT_FOUND); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_TAG); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_EXCEEDS_CREATE_CLAN_FREQUENCY); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CLAN_PASSPHRASE_INCORRECT); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_CANNOT_RECORD_BLACKLIST_ENTRY); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_ANNOUNCEMENT); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_VULGAR_WORDS_POSTED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_BLACKLIST_LIMIT_REACHED); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_BLACKLIST_ENTRY); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_INVALID_NP_MESSAGE_FORMAT); + STR_CASE(SCE_NP_CLANS_SERVER_ERROR_FAILED_TO_SEND_NP_MESSAGE); + } + + return unknown; + }); +} + +error_code sceNpClansInit(vm::cptr commId, vm::cptr passphrase, vm::ptr pool, vm::ptr poolSize, u32 flags) { sceNpClans.warning("sceNpClansInit(commId=*0x%x, passphrase=*0x%x, pool=*0x%x, poolSize=*0x%x, flags=0x%x)", commId, passphrase, pool, poolSize, flags); + const auto clans_manager = g_fxo->get(); + + if (clans_manager->is_initialized) + { + return SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED; + } + + if (!commId || !passphrase) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + if (flags != 0) { return SCE_NP_CLANS_ERROR_NOT_SUPPORTED; } + clans_manager->is_initialized = true; + return CELL_OK; } -s32 sceNpClansTerm() +error_code sceNpClansTerm() { sceNpClans.warning("sceNpClansTerm()"); + const auto clans_manager = g_fxo->get(); + + if (!clans_manager->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + clans_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpClansCreateRequest(vm::ptr handle, u64 flags) +error_code sceNpClansCreateRequest(vm::ptr handle, u64 flags) { sceNpClans.todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!handle) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + if (flags != 0) { return SCE_NP_CLANS_ERROR_NOT_SUPPORTED; @@ -38,219 +138,705 @@ s32 sceNpClansCreateRequest(vm::ptr handle, u64 flags) return CELL_OK; } -s32 sceNpClansDestroyRequest(vm::ptr handle) +error_code sceNpClansDestroyRequest(vm::ptr handle) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansDestroyRequest(handle=*0x%x)", handle); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansAbortRequest(vm::ptr handle) +error_code sceNpClansAbortRequest(vm::ptr handle) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansAbortRequest(handle=*0x%x)", handle); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansCreateClan(vm::ptr handle, vm::cptr name, vm::cptr tag, vm::ptr clanId) +error_code sceNpClansCreateClan(vm::ptr handle, vm::cptr name, vm::cptr tag, vm::ptr clanId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansCreateClan(handle=*0x%x, name=%s, tag=%s, clanId=*0x%x)", handle, name, tag, clanId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!name || !tag || !clanId) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (strlen(name.get_ptr()) > SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH || strlen(tag.get_ptr()) > SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpClansDisbandClan(vm::ptr handle, u32 clanId) +error_code sceNpClansDisbandClan(vm::ptr handle, SceNpClanId clanId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansDisbandClan(handle=*0x%x, clanId=*0x%x)", handle, clanId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansGetClanList(vm::ptr handle, vm::cptr paging, vm::ptr clanList, vm::ptr pageResult) +error_code sceNpClansGetClanList(vm::ptr handle, vm::cptr paging, vm::ptr clanList, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetClanList(handle=*0x%x, paging=*0x%x, clanList=*0x%x, pageResult=*0x%x)", handle, paging, clanList, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !clanList)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansGetClanListByNpId() +error_code sceNpClansGetClanListByNpId(vm::ptr handle, vm::cptr paging, vm::cptr npid, vm::ptr clanList, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetClanListByNpId(handle=*0x%x, paging=*0x%x, npid=*0x%x, clanList=*0x%x, pageResult=*0x%x)", handle, paging, npid, clanList, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid || !pageResult || (paging && !clanList)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansSearchByProfile() +error_code sceNpClansSearchByProfile(vm::ptr handle, vm::cptr paging, vm::cptr search, vm::ptr results, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSearchByProfile(handle=*0x%x, paging=*0x%x, search=*0x%x, results=*0x%x, pageResult=*0x%x)", handle, paging, search, results, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!search || !pageResult || (paging && !results)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansSearchByName() +error_code sceNpClansSearchByName(vm::ptr handle, vm::cptr paging, vm::cptr search, vm::ptr results, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSearchByName(handle=*0x%x, paging=*0x%x, search=*0x%x, results=*0x%x, pageResult=*0x%x)", handle, paging, search, results, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!search || !pageResult || (paging && !results)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansGetClanInfo() +error_code sceNpClansGetClanInfo(vm::ptr handle, SceNpClanId clanId, vm::ptr info) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetClanInfo(handle=*0x%x, clanId=%d, info=*0x%x)", handle, clanId, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + // TODO: add more checks for info + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansUpdateClanInfo() +error_code sceNpClansUpdateClanInfo(vm::ptr handle, SceNpClanId clanId, vm::cptr info) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansUpdateClanInfo(handle=*0x%x, clanId=%d, info=*0x%x)", handle, clanId, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + // TODO: add more checks for info + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + //if (info->something > X) + //{ + // return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + //} + return CELL_OK; } -s32 sceNpClansGetMemberList() +error_code sceNpClansGetMemberList(vm::ptr handle, SceNpClanId clanId, vm::cptr paging, SceNpClansMemberStatus status, vm::ptr memList, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetMemberList(handle=*0x%x, clanId=%d, paging=*0x%x, status=%d, memList=*0x%x, pageResult=*0x%x)", handle, clanId, paging, status, memList, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !memList)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansGetMemberInfo() +error_code sceNpClansGetMemberInfo(vm::ptr handle, SceNpClanId clanId, vm::cptr npid, vm::ptr memInfo) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetMemberInfo(handle=*0x%x, clanId=%d, npid=*0x%x, memInfo=*0x%x)", handle, clanId, npid, memInfo); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid || !memInfo) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansUpdateMemberInfo() +error_code sceNpClansUpdateMemberInfo(vm::ptr handle, SceNpClanId clanId, vm::cptr info) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansUpdateMemberInfo(handle=*0x%x, clanId=%d, memInfo=*0x%x)", handle, clanId, info); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!info) + { + // TODO: add more checks for info + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + //if (info->something > X) + //{ + // return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + //} + return CELL_OK; } -s32 sceNpClansChangeMemberRole() +error_code sceNpClansChangeMemberRole(vm::ptr handle, SceNpClanId clanId, vm::cptr npid, u32 role) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansChangeMemberRole(handle=*0x%x, clanId=%d, npid=*0x%x, role=%d)", handle, clanId, npid, role); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid || role > SCE_NP_CLANS_ROLE_LEADER) // TODO: check if role can be 0 + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansGetAutoAcceptStatus() +error_code sceNpClansGetAutoAcceptStatus(vm::ptr handle, SceNpClanId clanId, vm::ptr enable) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetAutoAcceptStatus(handle=*0x%x, clanId=%d, enable=*0x%x)", handle, clanId, enable); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!enable) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansUpdateAutoAcceptStatus() +error_code sceNpClansUpdateAutoAcceptStatus(vm::ptr handle, SceNpClanId clanId, b8 enable) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansUpdateAutoAcceptStatus(handle=*0x%x, clanId=%d, enable=%d)", handle, clanId, enable); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansJoinClan() +error_code sceNpClansJoinClan(vm::ptr handle, SceNpClanId clanId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansJoinClan(handle=*0x%x, clanId=%d)", handle, clanId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansLeaveClan() +error_code sceNpClansLeaveClan(vm::ptr handle, SceNpClanId clanId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansLeaveClan(handle=*0x%x, clanId=%d)", handle, clanId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansKickMember(vm::ptr handle, u32 clanId, vm::ptr npid, vm::ptr message) +error_code sceNpClansKickMember(vm::ptr handle, SceNpClanId clanId, vm::cptr npid, vm::cptr message) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansKickMember(handle=*0x%x, clanId=%d, npid=*0x%x, message=*0x%x)", handle, clanId, npid, message); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (message) + { + if (strlen(message->body) > SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansSendInvitation(vm::ptr handle, u32 clanId, vm::ptr npid, vm::ptr message) +error_code sceNpClansSendInvitation(vm::ptr handle, SceNpClanId clanId, vm::cptr npid, vm::cptr message) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSendInvitation(handle=*0x%x, clanId=%d, npid=*0x%x, message=*0x%x)", handle, clanId, npid, message); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (message) + { + if (strlen(message->body) > SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansCancelInvitation() +error_code sceNpClansCancelInvitation(vm::ptr handle, SceNpClanId clanId, vm::cptr npid) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansCancelInvitation(handle=*0x%x, clanId=%d, npid=*0x%x)", handle, clanId, npid); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansSendInvitationResponse(vm::ptr handle, u32 clanId, vm::ptr message, b8 accept) +error_code sceNpClansSendInvitationResponse(vm::ptr handle, SceNpClanId clanId, vm::cptr message, b8 accept) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSendInvitationResponse(handle=*0x%x, clanId=%d, message=*0x%x, accept=%d)", handle, clanId, message, accept); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (message) + { + if (strlen(message->body) > SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansSendMembershipRequest(vm::ptr handle, u32 clanId, vm::ptr message) +error_code sceNpClansSendMembershipRequest(vm::ptr handle, u32 clanId, vm::cptr message) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSendMembershipRequest(handle=*0x%x, clanId=%d, message=*0x%x)", handle, clanId, message); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (message) + { + if (strlen(message->body) > SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansCancelMembershipRequest() +error_code sceNpClansCancelMembershipRequest(vm::ptr handle, SceNpClanId clanId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansCancelMembershipRequest(handle=*0x%x, clanId=%d)", handle, clanId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansSendMembershipResponse() +error_code sceNpClansSendMembershipResponse(vm::ptr handle, SceNpClanId clanId, vm::cptr npid, vm::cptr message, b8 allow) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansSendMembershipResponse(handle=*0x%x, clanId=%d, npid=*0x%x, message=*0x%x, allow=%d)", handle, clanId, npid, message, allow); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (message) + { + if (strlen(message->body) > SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansGetBlacklist() +error_code sceNpClansGetBlacklist(vm::ptr handle, SceNpClanId clanId, vm::cptr paging, vm::ptr bl, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansGetBlacklist(handle=*0x%x, clanId=%d, paging=*0x%x, bl=*0x%x, pageResult=*0x%x)", handle, clanId, paging, bl, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !bl)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansAddBlacklistEntry() +error_code sceNpClansAddBlacklistEntry(vm::ptr handle, SceNpClanId clanId, vm::cptr npid) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansAddBlacklistEntry(handle=*0x%x, clanId=%d, npid=*0x%x)", handle, clanId, npid); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansRemoveBlacklistEntry() +error_code sceNpClansRemoveBlacklistEntry(vm::ptr handle, SceNpClanId clanId, vm::cptr npid) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRemoveBlacklistEntry(handle=*0x%x, clanId=%d, npid=*0x%x)", handle, clanId, npid); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!npid) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + return CELL_OK; } -s32 sceNpClansRetrieveAnnouncements() +error_code sceNpClansRetrieveAnnouncements(vm::ptr handle, SceNpClanId clanId, vm::cptr paging, vm::ptr mlist, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRetrieveAnnouncements(handle=*0x%x, clanId=%d, paging=*0x%x, mlist=*0x%x, pageResult=*0x%x)", handle, clanId, paging, mlist, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !mlist)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansPostAnnouncement() +error_code sceNpClansPostAnnouncement(vm::ptr handle, SceNpClanId clanId, vm::cptr message, vm::cptr data, u32 duration, vm::ptr mId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansPostAnnouncement(handle=*0x%x, clanId=%d, message=*0x%x, data=*0x%x, duration=%d, mId=*0x%x)", handle, clanId, message, data, duration, mId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!message || !mId || duration == 0) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (!data) // TODO verify + { + return SCE_NP_CLANS_ERROR_NOT_SUPPORTED; + } + + if (strlen(message->body) > SCE_NP_CLANS_ANNOUNCEMENT_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpClansRemoveAnnouncement() +error_code sceNpClansRemoveAnnouncement(vm::ptr handle, SceNpClanId clanId, SceNpClansMessageId mId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansPostAnnouncement(handle=*0x%x, clanId=%d, mId=%d)", handle, clanId, mId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansPostChallenge(vm::ptr handle, u32 clanId, u32 targetClan, vm::ptr message, vm::ptr data, u32 duration, vm::ptr mId) +error_code sceNpClansPostChallenge(vm::ptr handle, SceNpClanId clanId, SceNpClanId targetClan, vm::cptr message, vm::cptr data, u32 duration, vm::ptr mId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansPostChallenge(handle=*0x%x, clanId=%d, targetClan=%d, message=*0x%x, data=*0x%x, duration=%d, mId=*0x%x)", handle, clanId, targetClan, message, data, duration, mId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!message || !mId || duration == 0) + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (!data) // TODO verify + { + return SCE_NP_CLANS_ERROR_NOT_SUPPORTED; + } + + if (strlen(message->body) > SCE_NP_CLANS_ANNOUNCEMENT_MESSAGE_BODY_MAX_LENGTH || strlen(message->subject) > SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH) // TODO: correct max? + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + return CELL_OK; } -s32 sceNpClansRetrievePostedChallenges() +error_code sceNpClansRetrievePostedChallenges(vm::ptr handle, SceNpClanId clanId, SceNpClanId targetClan, vm::cptr paging, vm::ptr mList, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRetrievePostedChallenges(handle=*0x%x, clanId=%d, targetClan=%d, paging=*0x%x, mList=*0x%x, pageResult=*0x%x)", handle, clanId, targetClan, paging, mList, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !mList)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansRemovePostedChallenge() +error_code sceNpClansRemovePostedChallenge(vm::ptr handle, SceNpClanId clanId, SceNpClanId targetClan, SceNpClansMessageId mId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRemovePostedChallenge(handle=*0x%x, clanId=%d, targetClan=%d, mId=%d)", handle, clanId, targetClan, mId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } -s32 sceNpClansRetrieveChallenges() +error_code sceNpClansRetrieveChallenges(vm::ptr handle, SceNpClanId clanId, vm::cptr paging, vm::ptr mList, vm::ptr pageResult) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRetrieveChallenges(handle=*0x%x, clanId=%d, paging=*0x%x, mList=*0x%x, pageResult=*0x%x)", handle, clanId, paging, mList, pageResult); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + + if (!pageResult || (paging && !mList)) // TODO: confirm + { + return SCE_NP_CLANS_ERROR_INVALID_ARGUMENT; + } + + if (paging) + { + if (paging->startPos > SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX || paging->max > SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX) + { + return SCE_NP_CLANS_ERROR_EXCEEDS_MAX; + } + } + return CELL_OK; } -s32 sceNpClansRemoveChallenge() +error_code sceNpClansRemoveChallenge(SceNpClansRequestHandle handle, SceNpClanId clanId, SceNpClansMessageId mId) { - UNIMPLEMENTED_FUNC(sceNpClans); + sceNpClans.todo("sceNpClansRemoveChallenge(handle=*0x%x, clanId=%d, mId=%d)", handle, clanId, mId); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_CLANS_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } diff --git a/rpcs3/Emu/Cell/Modules/sceNpClans.h b/rpcs3/Emu/Cell/Modules/sceNpClans.h index 44035aab2d..d7e0c66b33 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpClans.h +++ b/rpcs3/Emu/Cell/Modules/sceNpClans.h @@ -1,11 +1,13 @@ -#pragma once +#pragma once #include "sceNp.h" #include "Utilities/BEType.h" +#include + // Return codes -enum +enum SceNpClansError : u32 { SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED = 0x80022701, SCE_NP_CLANS_ERROR_NOT_INITIALIZED = 0x80022702, @@ -225,8 +227,8 @@ struct SceNpClansMemberEntry // Clan message structure struct SceNpClansMessage { - s8 subject[SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH + 1]; - s8 body[SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH + 1]; + char subject[SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH + 1]; + char body[SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH + 1]; be_t options; }; @@ -254,3 +256,10 @@ struct SceNpClansBlacklistEntry SceNpId entry; SceNpId registeredBy; }; + +// fxm objects + +struct sce_np_clans_manager +{ + std::atomic is_initialized = false; +}; diff --git a/rpcs3/Emu/Cell/Modules/sceNpSns.cpp b/rpcs3/Emu/Cell/Modules/sceNpSns.cpp index 28951e6d69..31979e6c24 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpSns.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNpSns.cpp @@ -1,8 +1,9 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/IdManager.h" #include "Emu/Cell/PPUModule.h" #include "sceNpSns.h" +#include "sceNp.h" LOG_CHANNEL(sceNpSns); @@ -41,6 +42,13 @@ error_code sceNpSnsFbInit(vm::cptr params) { sceNpSns.todo("sceNpSnsFbInit(params=*0x%x)", params); + const auto manager = g_fxo->get(); + + if (manager->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_ALREADY_INITIALIZED; + } + if (!params) { return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; @@ -48,6 +56,8 @@ error_code sceNpSnsFbInit(vm::cptr params) // TODO: Use the initialization parameters somewhere + manager->is_initialized = true; + return CELL_OK; } @@ -55,6 +65,15 @@ error_code sceNpSnsFbTerm() { sceNpSns.warning("sceNpSnsFbTerm()"); + const auto manager = g_fxo->get(); + + if (!manager->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; + } + + manager->is_initialized = false; + return CELL_OK; } @@ -62,11 +81,21 @@ error_code sceNpSnsFbCreateHandle(vm::ptr handle) { sceNpSns.warning("sceNpSnsFbCreateHandle(handle=*0x%x)", handle); - if (!handle) + if (!g_fxo->get()->is_initialized) { return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; } + if (!handle) + { + return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; + } + + //if (count > SCE_NP_SNS_FB_HANDLE_SLOT_MAX) + //{ + // return SCE_NP_SNS_FB_ERROR_EXCEEDS_MAX; + //} + *handle = idm::make(); return CELL_OK; @@ -76,6 +105,11 @@ error_code sceNpSnsFbDestroyHandle(u32 handle) { sceNpSns.warning("sceNpSnsFbDestroyHandle(handle=%d)", handle); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; + } + if (handle == SCE_NP_SNS_FB_INVALID_HANDLE || handle > SCE_NP_SNS_FB_HANDLE_SLOT_MAX) { return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; @@ -97,6 +131,11 @@ error_code sceNpSnsFbAbortHandle(u32 handle) { sceNpSns.todo("sceNpSnsFbAbortHandle(handle=%d)", handle); + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; + } + if (handle == SCE_NP_SNS_FB_INVALID_HANDLE || handle > SCE_NP_SNS_FB_HANDLE_SLOT_MAX) { return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; @@ -118,6 +157,11 @@ error_code sceNpSnsFbGetAccessToken(u32 handle, vm::cptrget()->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; + } + if (handle == SCE_NP_SNS_FB_INVALID_HANDLE || handle > SCE_NP_SNS_FB_HANDLE_SLOT_MAX || !param || !result || !param->fb_app_id) { return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; @@ -130,6 +174,11 @@ error_code sceNpSnsFbGetAccessToken(u32 handle, vm::cptr param, vm::ptr result) { - UNIMPLEMENTED_FUNC(sceNpSns); + sceNpSns.todo("sceNpSnsFbGetLongAccessToken(handle=%d, param=*0x%x, result=*0x%x)", handle, param, result); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED; + } + + if (handle == SCE_NP_SNS_FB_INVALID_HANDLE || handle > SCE_NP_SNS_FB_HANDLE_SLOT_MAX || !param || !result || !param->fb_app_id) + { + return SCE_NP_SNS_ERROR_INVALID_ARGUMENT; + } + + const auto sfh = idm::get(handle); + + if (!sfh) + { + return SCE_NP_SNS_FB_ERROR_UNKNOWN_HANDLE; + } + + if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) + { + return SCE_NP_SNS_ERROR_NOT_SIGN_IN; + } + return CELL_OK; } diff --git a/rpcs3/Emu/Cell/Modules/sceNpSns.h b/rpcs3/Emu/Cell/Modules/sceNpSns.h index 93c3a18402..8e90fe0a89 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpSns.h +++ b/rpcs3/Emu/Cell/Modules/sceNpSns.h @@ -1,7 +1,9 @@ -#pragma once +#pragma once #include "Emu/Memory/vm_ptr.h" +#include + // Return codes enum sceNpSnsError : u32 { @@ -25,13 +27,20 @@ enum sceNpSnsError : u32 SCE_NP_SNS_FB_ERROR_ACCESS_NOT_ALLOWED = 0x8002451c, }; +// Access token param options +enum +{ + SCE_NP_SNS_FB_ACCESS_TOKEN_PARAM_OPTIONS_SILENT = 0x00000001 +}; + // Constants for SNS functions enum { - SCE_NP_SNS_FB_INVALID_HANDLE = 0, - SCE_NP_SNS_FB_HANDLE_SLOT_MAX = 4, - SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX = 255, - SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX = 255 + SCE_NP_SNS_FB_INVALID_HANDLE = 0, + SCE_NP_SNS_FB_HANDLE_SLOT_MAX = 4, + SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX = 255, + SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX = 255, + SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX = 4096 }; struct sns_fb_handle_t @@ -61,3 +70,16 @@ struct SceNpSnsFbAccessTokenResult be_t expiration; char access_token[SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX + 1]; }; + +struct SceNpSnsFbLongAccessTokenResult +{ + be_t expiration; + char access_token[SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX + 1]; +}; + +// fxm objects + +struct sce_np_sns_manager +{ + std::atomic is_initialized = false; +}; diff --git a/rpcs3/Emu/Cell/Modules/sceNpTus.cpp b/rpcs3/Emu/Cell/Modules/sceNpTus.cpp index 9dd8de22ab..026e3ce57d 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpTus.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNpTus.cpp @@ -1,22 +1,41 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" +#include "Emu/IdManager.h" #include "sceNp.h" #include "sceNpTus.h" LOG_CHANNEL(sceNpTus); -s32 sceNpTusInit() +error_code sceNpTusInit(s32 prio) { - sceNpTus.warning("sceNpTusInit()"); + sceNpTus.warning("sceNpTusInit(prio=%d)", prio); + + const auto tus_manager = g_fxo->get(); + + if (tus_manager->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED; + } + + tus_manager->is_initialized = true; return CELL_OK; } -s32 sceNpTusTerm() +error_code sceNpTusTerm() { sceNpTus.warning("sceNpTusTerm()"); + const auto tus_manager = g_fxo->get(); + + if (!tus_manager->is_initialized) + { + return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; + } + + tus_manager->is_initialized = false; + return CELL_OK; } diff --git a/rpcs3/Emu/Cell/Modules/sceNpTus.h b/rpcs3/Emu/Cell/Modules/sceNpTus.h index 6e19cf91a0..ca5340cdf8 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpTus.h +++ b/rpcs3/Emu/Cell/Modules/sceNpTus.h @@ -1,10 +1,12 @@ -#pragma once +#pragma once #include "Utilities/BEType.h" #include "cellRtc.h" #include "sceNp.h" +#include + // Constants for TUS functions and structures enum { @@ -49,3 +51,10 @@ struct SceNpTusDataStatus u8 pad[4]; SceNpTusDataInfo info; }; + +// fxm objects + +struct sce_np_tus_manager +{ + std::atomic is_initialized = false; +}; diff --git a/rpcs3/Emu/Cell/Modules/sceNpUtil.cpp b/rpcs3/Emu/Cell/Modules/sceNpUtil.cpp index 215c8cef65..1be8c1c76e 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpUtil.cpp +++ b/rpcs3/Emu/Cell/Modules/sceNpUtil.cpp @@ -1,32 +1,65 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/Cell/PPUModule.h" +#include "Emu/IdManager.h" #include "sceNp.h" #include "sceNpUtil.h" LOG_CHANNEL(sceNpUtil); -s32 sceNpUtilBandwidthTestInitStart(u32 prio, size_t stack) +error_code sceNpUtilBandwidthTestInitStart(u32 prio, u64 stack) { - UNIMPLEMENTED_FUNC(sceNpUtil); + sceNpUtil.todo("sceNpUtilBandwidthTestInitStart(prio=%d, stack=%d)", prio, stack); + + const auto util_manager = g_fxo->get(); + + if (util_manager->is_initialized) + { + return SCE_NP_ERROR_ALREADY_INITIALIZED; + } + + util_manager->is_initialized = true; + return CELL_OK; } -s32 sceNpUtilBandwidthTestGetStatus() +error_code sceNpUtilBandwidthTestGetStatus() { - UNIMPLEMENTED_FUNC(sceNpUtil); - return SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_FINISHED; + sceNpUtil.todo("sceNpUtilBandwidthTestGetStatus()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + return not_an_error(SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_FINISHED); } -s32 sceNpUtilBandwidthTestShutdown() +error_code sceNpUtilBandwidthTestShutdown(vm::ptr result) { - UNIMPLEMENTED_FUNC(sceNpUtil); + sceNpUtil.todo("sceNpUtilBandwidthTestShutdown(result=*0x%x)", result); + + const auto util_manager = g_fxo->get(); + + if (!util_manager->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + + util_manager->is_initialized = false; + return CELL_OK; } -s32 sceNpUtilBandwidthTestAbort() +error_code sceNpUtilBandwidthTestAbort() { - UNIMPLEMENTED_FUNC(sceNpUtil); + sceNpUtil.todo("sceNpUtilBandwidthTestAbort()"); + + if (!g_fxo->get()->is_initialized) + { + return SCE_NP_ERROR_NOT_INITIALIZED; + } + return CELL_OK; } diff --git a/rpcs3/Emu/Cell/Modules/sceNpUtil.h b/rpcs3/Emu/Cell/Modules/sceNpUtil.h index 3912eb322a..0f588b5de7 100644 --- a/rpcs3/Emu/Cell/Modules/sceNpUtil.h +++ b/rpcs3/Emu/Cell/Modules/sceNpUtil.h @@ -1,7 +1,24 @@ -#pragma once +#pragma once + +#include + enum { SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_NONE = 0, SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_RUNNING = 1, SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_FINISHED = 2 }; + +struct SceNpUtilBandwidthTestResult +{ + be_t upload_bps; + be_t download_bps; + be_t result; +}; + +// fxm objects + +struct sce_np_util_manager +{ + std::atomic is_initialized = false; +};