#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" #include "sysPrxForUser.h" #include "Emu/IdManager.h" #include "Crypto/unedat.h" #include "Crypto/unself.h" #include "cellRtc.h" #include "sceNp.h" #include "cellSysutil.h" LOG_CHANNEL(sceNp); int sceNpScoreGetRankingByRangeAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } 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_ERROR_DNS_HOST_NOT_FOUND); STR_CASE(SCE_NP_CORE_ERROR_DNS_TRY_AGAIN); STR_CASE(SCE_NP_CORE_ERROR_DNS_NO_RECOVERY); STR_CASE(SCE_NP_CORE_ERROR_DNS_NO_DATA); STR_CASE(SCE_NP_CORE_ERROR_DNS_NO_ADDRESS); 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; int sceNpInit(uint32_t poolsize, void* poolptr) { LOG_SCE_TRACE("(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr); int ret = SCE_ERROR_UNKNOWN; do { const auto manager = g_fxo->get(); if (manager->is_initialized) { ret = SCE_NP_ERROR_ALREADY_INITIALIZED; break; } if (poolsize == 0) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } else if (poolsize < SCE_NP_MIN_POOLSIZE) { ret = SCE_NP_ERROR_INSUFFICIENT_BUFFER; break; } if (!poolptr) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } manager->is_initialized = true; ret = SCE_OK; } while(false); return ret; } int sceNpTerm() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { const auto manager = g_fxo->get(); if (!manager->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } manager->is_initialized = false; ret = SCE_OK; } while(false); return ret; } error_code npDrmIsAvailable(vm::cptr k_licensee_addr, vm::cptr drm_path) { std::array k_licensee{}; if (k_licensee_addr) { std::copy_n(k_licensee_addr.get_ptr(), k_licensee.size(), k_licensee.begin()); sceNp.notice("npDrmIsAvailable(): KLicense key %s", *reinterpret_cast*>(k_licensee.data())); } const std::string enc_drm_path = drm_path.get_ptr(); if (!fs::is_file(vfs::get(enc_drm_path))) { sceNp.warning("npDrmIsAvailable(): '%s' not found", enc_drm_path); return CELL_ENOENT; } auto npdrmkeys = g_fxo->get(); npdrmkeys->devKlic.fill(0); npdrmkeys->rifKey.fill(0); std::string rap_dir_path = "/dev_hdd0/home/" + Emu.GetUsr() + "/exdata/"; const std::string& enc_drm_path_local = vfs::get(enc_drm_path); const fs::file enc_file(enc_drm_path_local); u32 magic; enc_file.read(magic); enc_file.seek(0); if (magic == "SCE\0"_u32) { if (!k_licensee_addr) k_licensee = get_default_self_klic(); if (verify_npdrm_self_headers(enc_file, k_licensee.data())) { npdrmkeys->devKlic = std::move(k_licensee); } else { sceNp.error("npDrmIsAvailable(): Failed to verify sce file %s", enc_drm_path); return SCE_NP_DRM_ERROR_NO_ENTITLEMENT; } } else if (magic == "NPD\0"_u32) { // edata / sdata files std::string contentID; if (VerifyEDATHeaderWithKLicense(enc_file, enc_drm_path_local, k_licensee, &contentID)) { const std::string rap_file = rap_dir_path + contentID + ".rap"; npdrmkeys->devKlic = std::move(k_licensee); if (fs::is_file(vfs::get(rap_file))) npdrmkeys->rifKey = GetEdatRifKeyFromRapFile(fs::file{ vfs::get(rap_file) }); else sceNp.warning("npDrmIsAvailable(): Rap file not found: %s", rap_file.c_str()); } else { sceNp.error("npDrmIsAvailable(): Failed to verify npd file %s", enc_drm_path); return SCE_NP_DRM_ERROR_NO_ENTITLEMENT; } } else { // for now assume its just unencrypted sceNp.notice("npDrmIsAvailable(): Assuming npdrm file is unencrypted at %s", enc_drm_path); } return CELL_OK; } int sceNpDrmIsAvailable(const uint8_t* k_licensee_addr, const char* drm_path) { LOG_SCE_TRACE("(k_licensee=*0x%x, drm_path=%s)", k_licensee_addr, drm_path); int ret = SCE_ERROR_UNKNOWN; do { ret = npDrmIsAvailable(k_licensee_addr, drm_path); break; } int sceNpDrmIsAvailable2(const uint8_t* k_licensee_addr, const char* drm_path) { LOG_SCE_TRACE("(k_licensee=*0x%x, drm_path=%s)", k_licensee_addr, drm_path); int ret = SCE_ERROR_UNKNOWN; do { ret = npDrmIsAvailable(k_licensee_addr, drm_path); break; } int sceNpDrmVerifyUpgradeLicense(const char* content_id) { LOG_SCE_TRACE("(content_id=%s)", content_id); int ret = SCE_ERROR_UNKNOWN; do { if (!content_id) { ret = SCE_NP_DRM_ERROR_INVALID_PARAM; break; } if (!fs::is_file(vfs::get("/dev_hdd0/home/" + Emu.GetUsr() + "/exdata/" + content_id.get_ptr() + ".rap"))) { // Game hasn't been purchased therefore no RAP file present ret = SCE_NP_DRM_ERROR_LICENSE_NOT_FOUND; break; } // Game has been purchased and there's a RAP file present ret = SCE_OK; } while(false); return ret; } int sceNpDrmVerifyUpgradeLicense2(const char* content_id) { LOG_SCE_TRACE("(content_id=%s)", content_id); int ret = SCE_ERROR_UNKNOWN; do { if (!content_id) { ret = SCE_NP_DRM_ERROR_INVALID_PARAM; break; } if (!fs::is_file(vfs::get("/dev_hdd0/home/" + Emu.GetUsr() + "/exdata/" + content_id.get_ptr() + ".rap"))) { // Game hasn't been purchased therefore no RAP file present ret = SCE_NP_DRM_ERROR_LICENSE_NOT_FOUND; break; } // Game has been purchased and there's a RAP file present ret = SCE_OK; } while(false); return ret; } int sceNpDrmExecuteGamePurchase() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpDrmGetTimelimit(const char* path, uint64_t* time_remain) { LOG_SCE_TRACE("(path=%s, time_remain=*0x%x)", path, time_remain); int ret = SCE_ERROR_UNKNOWN; do { if (!path || !time_remain) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } *time_remain = 0x7FFFFFFFFFFFFFFFULL; ret = SCE_OK; } while(false); return ret; } int sceNpDrmProcessExitSpawn(ppu_thread& ppu, const uint8_t* klicensee, const char* path, vm::cpptr argv, vm::cpptr envp, uint32_t data, uint32_t data_size, int32_t prio, uint64_t flags) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (s32 error = npDrmIsAvailable(klicensee, path)) { ret = error; break; } sys_game_process_exitspawn(ppu, path, argv, envp, data, data_size, prio, flags); ret = SCE_OK; } while(false); return ret; } int sceNpDrmProcessExitSpawn2(ppu_thread& ppu, const uint8_t* klicensee, const char* path, vm::cpptr argv, vm::cpptr envp, uint32_t data, uint32_t data_size, int32_t prio, uint64_t flags) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (s32 error = npDrmIsAvailable(klicensee, path)) { ret = error; break; } sys_game_process_exitspawn2(ppu, path, argv, envp, data, data_size, prio, flags); ret = SCE_OK; } while(false); return ret; } int sceNpBasicRegisterHandler(const SceNpCommunicationId* context, SceNpBasicEventHandler* handler, void* arg) { LOG_SCE_TRACE("(context=*0x%x, handler=*0x%x, arg=*0x%x)", context, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!context || !handler) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicRegisterContextSensitiveHandler(const SceNpCommunicationId* context, SceNpBasicEventHandler* handler, void* arg) { LOG_SCE_TRACE("(context=*0x%x, handler=*0x%x, arg=*0x%x)", context, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!context || !handler) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicUnregisterHandler() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSetPresence(const void* data, uint64_t size) { LOG_SCE_TRACE("(data=*0x%x, size=%d)", data, size); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSetPresenceDetails(const SceNpBasicPresenceDetails* pres, uint32_t options) { LOG_SCE_TRACE("(pres=*0x%x, options=0x%x)", pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!pres || options > SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (pres->size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSetPresenceDetails2(const SceNpBasicPresenceDetails2* pres, uint32_t options) { LOG_SCE_TRACE("(pres=*0x%x, options=0x%x)", pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!pres || options > SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (pres->size > SCE_NP_BASIC_MAX_PRESENCE_SIZE) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSendMessage(const SceNpId* to, const void* data, uint64_t size) { LOG_SCE_TRACE("(to=*0x%x, data=*0x%x, size=%d)", to, data, size); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!to || to->handle.data[0] == '\0' || !data || !size) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (size > SCE_NP_BASIC_MAX_MESSAGE_SIZE) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSendMessageGui(const SceNpBasicMessageDetails* msg, sys_memory_container_t containerId) { LOG_SCE_TRACE("(msg=*0x%x, containerId=%d)", msg, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!msg || msg->count > SCE_NP_BASIC_SEND_MESSAGE_MAX_RECIPIENTS || msg->npids.handle.data[0] == '\0' || !(msg->msgFeatures & SCE_NP_BASIC_MESSAGE_FEATURES_ALL_FEATURES)) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (msg->size > SCE_NP_BASIC_MAX_MESSAGE_SIZE) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = not_an_error(SCE_NP_BASIC_ERROR_NOT_CONNECTED); break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicSendMessageAttachment(const SceNpId* to, const char* subject, const char* body, const char* data, uint64_t size, sys_memory_container_t containerId) { LOG_SCE_TRACE("(to=*0x%x, subject=%s, body=%s, data=%s, size=%d, containerId=%d)", to, subject, body, data, size, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!to || to->handle.data[0] == '\0' || !data || !size) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (strlen(subject.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX || strlen(body.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = not_an_error(SCE_NP_BASIC_ERROR_NOT_CONNECTED); break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicRecvMessageAttachment(sys_memory_container_t containerId) { LOG_SCE_TRACE("(containerId=%d)", containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicRecvMessageAttachmentLoad(uint32_t id, void* buffer, uint64_t* size) { LOG_SCE_TRACE("(id=%d, buffer=*0x%x, size=*0x%x)", id, buffer, size); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!buffer || !size) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (id > SCE_NP_BASIC_SELECTED_MESSAGE_DATA) { ret = SCE_NP_BASIC_ERROR_INVALID_DATA_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicRecvMessageCustom(uint16_t mainType, uint32_t recvOptions, sys_memory_container_t containerId) { LOG_SCE_TRACE("(mainType=%d, recvOptions=%d, containerId=%d)", mainType, recvOptions, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!(recvOptions & SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ALL_OPTIONS)) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicMarkMessageAsUsed(SceNpBasicMessageId msgId) { LOG_SCE_TRACE("(msgId=%d)", msgId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } //if (!msgId > ?) //{ // ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; //} ret = SCE_OK; } while(false); return ret; } int sceNpBasicAbortGui() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicAddFriend(const SceNpId* contact, const char* body, sys_memory_container_t containerId) { LOG_SCE_TRACE("(contact=*0x%x, body=%s, containerId=%d)", contact, body, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!contact || contact->handle.data[0] == '\0') { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (strlen(body.get_ptr()) > SCE_NP_BASIC_BODY_CHARACTER_MAX) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = not_an_error(SCE_NP_BASIC_ERROR_NOT_CONNECTED); break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendListEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are any friends *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendListEntry(uint32_t index, SceNpId* npid) { LOG_SCE_TRACE("(index=%d, npid=*0x%x)", index, npid); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendPresenceByIndex(uint32_t index, SceNpUserInfo* user, SceNpBasicPresenceDetails* pres, uint32_t options) { LOG_SCE_TRACE("(index=%d, user=*0x%x, pres=*0x%x, options=%d)", index, user, pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!user || !pres) { // TODO: check index and (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendPresenceByIndex2(uint32_t index, SceNpUserInfo* user, SceNpBasicPresenceDetails2* pres, uint32_t options) { LOG_SCE_TRACE("(index=%d, user=*0x%x, pres=*0x%x, options=%d)", index, user, pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!user || !pres) { // TODO: check index and (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendPresenceByNpId(const SceNpId* npid, SceNpBasicPresenceDetails* pres, uint32_t options) { LOG_SCE_TRACE("(npid=*0x%x, pres=*0x%x, options=%d)", npid, pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid || !pres) { // TODO: check (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetFriendPresenceByNpId2(const SceNpId* npid, SceNpBasicPresenceDetails2* pres, uint32_t options) { LOG_SCE_TRACE("(npid=*0x%x, pres=*0x%x, options=%d)", npid, pres, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid || !pres) { // TODO: check (options & SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS) depending on fw ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicAddPlayersHistory(const SceNpId* npid, char* description) { LOG_SCE_TRACE("(npid=*0x%x, description=*0x%x)", npid, description); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid || npid->handle.data[0] == '\0') { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (description && strlen(description.get_ptr()) > SCE_NP_BASIC_DESCRIPTION_CHARACTER_MAX) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicAddPlayersHistoryAsync(const SceNpId* npids, uint32_t count, char* description, uint32_t* reqId) { LOG_SCE_TRACE("(npids=*0x%x, count=%d, description=*0x%x, reqId=*0x%x)", npids, count, description, reqId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (count > SCE_NP_BASIC_PLAYER_HISTORY_MAX_PLAYERS) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } if (!npids) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } for (u32 i = 0; i < count; i++) { if (npids[i].handle.data[0] == '\0') { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } } if (description && strlen(description.get_ptr()) > SCE_NP_BASIC_DESCRIPTION_CHARACTER_MAX) { ret = SCE_NP_BASIC_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetPlayersHistoryEntryCount(uint32_t options, uint32_t* count) { LOG_SCE_TRACE("(options=%d, count=*0x%x)", options, count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are players histories *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetPlayersHistoryEntry(uint32_t options, uint32_t index, SceNpId* npid) { LOG_SCE_TRACE("(options=%d, index=%d, npid=*0x%x)", options, index, npid); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid) { // TODO: Check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicAddBlockListEntry(const SceNpId* npid) { LOG_SCE_TRACE("(npid=*0x%x)", npid); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid || npid->handle.data[0] == '\0') { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = not_an_error(SCE_NP_BASIC_ERROR_NOT_CONNECTED); break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetBlockListEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are block lists *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetBlockListEntry(uint32_t index, SceNpId* npid) { LOG_SCE_TRACE("(index=%d, npid=*0x%x)", index, npid); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!npid) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMessageAttachmentEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are message attachments *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMessageAttachmentEntry(uint32_t index, SceNpUserInfo* from) { LOG_SCE_TRACE("(index=%d, from=*0x%x)", index, from); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!from) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetCustomInvitationEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!count) { ret = SCE_NP_AUTH_EINVAL; break; } // TODO: Find the correct test which ret =s SCE_NP_AUTH_ESRCH break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_AUTH_ESRCH; break; } // TODO: Check if there are custom invitations *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetCustomInvitationEntry(uint32_t index, SceNpUserInfo* from) { LOG_SCE_TRACE("(index=%d, from=*0x%x)", index, from); int ret = SCE_ERROR_UNKNOWN; do { if (!from) { // TODO: check index ret = SCE_NP_AUTH_EINVAL; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_AUTH_ESRCH; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMatchingInvitationEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are matching invitations *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMatchingInvitationEntry(uint32_t index, SceNpUserInfo* from) { LOG_SCE_TRACE("(index=%d, from=*0x%x)", index, from); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!from) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetClanMessageEntryCount(uint32_t* count) { LOG_SCE_TRACE("(count=*0x%x)", count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are clan messages *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetClanMessageEntry(uint32_t index, SceNpUserInfo* from) { LOG_SCE_TRACE("(index=%d, from=*0x%x)", index, from); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!from) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMessageEntryCount(uint32_t type, uint32_t* count) { LOG_SCE_TRACE("(type=%d, count=*0x%x)", type, count); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!count) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } // TODO: Check if there are messages *count = 0; ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetMessageEntry(uint32_t type, uint32_t index, SceNpUserInfo* from) { LOG_SCE_TRACE("(type=%d, index=%d, from=*0x%x)", type, index, from); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!from) { // TODO: check index ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // TODO: Find the correct test which ret =s SCE_NP_ERROR_ID_NOT_FOUND break; if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_ID_NOT_FOUND; break; } ret = SCE_OK; } while(false); return ret; } int sceNpBasicGetEvent(int32_t* event, SceNpUserInfo* from, int32_t* data, uint32_t* size) { LOG_SCE_TRACE("(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_BASIC_ERROR_NOT_INITIALIZED; break; } if (!event || !from || !data || !size) { ret = SCE_NP_BASIC_ERROR_INVALID_ARGUMENT; break; } // 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 ret = not_an_error(SCE_NP_BASIC_ERROR_NO_EVENT); break; } int sceNpCommerceCreateCtx(uint32_t version, SceNpId* npId, SceNpCommerceHandler* handler, void* arg, uint32_t* ctx_id) { LOG_SCE_TRACE("(version=%d, event=*0x%x, from=*0x%x, arg=*0x%x, ctx_id=*0x%x)", version, npId, handler, arg, ctx_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceDestroyCtx(uint32_t ctx_id) { LOG_SCE_TRACE("(ctx_id=%d)", ctx_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceInitProductCategory(SceNpCommerceProductCategory* pc, const void* data, uint64_t data_size) { LOG_SCE_TRACE("(pc=*0x%x, data=*0x%x, data_size=%d)", pc, data, data_size); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } void sceNpCommerceDestroyProductCategory(vm::ptr pc) { sceNp.todo("sceNpCommerceDestroyProductCategory(pc=*0x%x)", pc); } int sceNpCommerceGetProductCategoryStart(uint32_t ctx_id, const char* category_id, int32_t lang_code, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, category_id=%s, lang_code=%d, req_id=*0x%x)", ctx_id, category_id, lang_code, req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetProductCategoryFinish(uint32_t req_id) { LOG_SCE_TRACE("(req_id=%d)", req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetProductCategoryResult(uint32_t req_id, void* buf, uint64_t buf_size, uint64_t* fill_size) { LOG_SCE_TRACE("(req_id=%d, buf=*0x%x, buf_size=%d, fill_size=*0x%x)", req_id, buf, buf_size, fill_size); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetProductCategoryAbort(uint32_t req_id) { LOG_SCE_TRACE("(req_id=%d)", req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } 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; } int sceNpCommerceGetCategoryInfo(SceNpCommerceProductCategory* pc, SceNpCommerceCategoryInfo* info) { LOG_SCE_TRACE("(pc=*0x%x, info=*0x%x)", pc, info); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } 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; } int sceNpCommerceGetCurrencyInfo(SceNpCommerceProductCategory* pc, SceNpCommerceCurrencyInfo* info) { LOG_SCE_TRACE("(pc=*0x%x, info=*0x%x)", pc, info); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetNumOfChildCategory(SceNpCommerceProductCategory* pc, uint32_t* num) { LOG_SCE_TRACE("(pc=*0x%x, num=*0x%x)", pc, num); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetNumOfChildProductSku(SceNpCommerceProductCategory* pc, uint32_t* num) { LOG_SCE_TRACE("(pc=*0x%x, num=*0x%x)", pc, num); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } 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; } int sceNpCommerceSetDataFlagStart() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetDataFlagStart() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceSetDataFlagFinish() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetDataFlagFinish() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetDataFlagState() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetDataFlagAbort() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetChildCategoryInfo(SceNpCommerceProductCategory* pc, uint32_t child_index, SceNpCommerceCategoryInfo* info) { LOG_SCE_TRACE("(pc=*0x%x, child_index=%d, info=*0x%x)", pc, child_index, info); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceGetChildProductSkuInfo(SceNpCommerceProductCategory* pc, uint32_t child_index, SceNpCommerceProductSkuInfo* info) { LOG_SCE_TRACE("(pc=*0x%x, child_index=%d, info=*0x%x)", pc, child_index, info); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceDoCheckoutStartAsync(uint32_t ctx_id, vm::cpptr sku_ids, uint32_t sku_num, sys_memory_container_t container, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCommerceDoCheckoutFinishAsync(uint32_t req_id) { LOG_SCE_TRACE("(req_id=%d)", req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpCustomMenuRegisterActions(const SceNpCustomMenu* menu, SceNpCustomMenuEventHandler* handler, void* userArg, uint64_t options) { LOG_SCE_TRACE("(menu=*0x%x, handler=*0x%x, userArg=*0x%x, options=0x%x)", menu, handler, userArg, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } if (!menu || !handler) { ret = SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpCustomMenuActionSetActivation(const SceNpCustomMenuIndexArray* array, uint64_t options) { LOG_SCE_TRACE("(array=*0x%x, options=0x%x)", array, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } if (!array) { ret = SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpCustomMenuRegisterExceptionList(const SceNpCustomMenuActionExceptions* items, uint32_t numItems, uint64_t options) { LOG_SCE_TRACE("(items=*0x%x, numItems=%d, options=0x%x)", items, numItems, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } if (!items) { ret = SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT; break; } if (numItems > SCE_NP_CUSTOM_MENU_ACTION_ITEMS_MAX) { // TODO: what about SCE_NP_CUSTOM_MENU_ACTION_ITEMS_TOTAL_MAX ret = SCE_NP_CUSTOM_MENU_ERROR_EXCEEDS_MAX; break; } ret = SCE_OK; } while(false); return ret; } int sceNpFriendlist(SceNpFriendlistResultHandler* resultHandler, void* userArg, sys_memory_container_t containerId) { LOG_SCE_TRACE("(resultHandler=*0x%x, userArg=*0x%x, containerId=%d)", resultHandler, userArg, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } if (!resultHandler) { ret = SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpFriendlistCustom(SceNpFriendlistCustomOptions options, SceNpFriendlistResultHandler* resultHandler, void* userArg, sys_memory_container_t containerId) { LOG_SCE_TRACE("(options=0x%x, resultHandler=*0x%x, userArg=*0x%x, containerId=%d)", options, resultHandler, userArg, containerId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } if (!resultHandler) { ret = SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpFriendlistAbortGui() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupInit() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { const auto lookup_manager = g_fxo->get(); if (lookup_manager->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED; break; } if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } lookup_manager->is_initialized = true; ret = SCE_OK; } while(false); return ret; } int sceNpLookupTerm() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { const auto lookup_manager = g_fxo->get(); if (!lookup_manager->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } lookup_manager->is_initialized = false; ret = SCE_OK; } while(false); return ret; } int sceNpLookupCreateTitleCtx(const SceNpCommunicationId* communicationId, const SceNpId* selfNpId) { LOG_SCE_TRACE("(communicationId=*0x%x, selfNpId=0x%x)", communicationId, selfNpId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!communicationId || !selfNpId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupDestroyTitleCtx(const SceNpCommunicationId* communicationId, const SceNpId* selfNpId) { LOG_SCE_TRACE("(communicationId=*0x%x, selfNpId=0x%x)", communicationId, selfNpId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!communicationId || !selfNpId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupCreateTransactionCtx(int32_t titleCtxId) { LOG_SCE_TRACE("(titleCtxId=%d)", titleCtxId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupDestroyTransactionCtx(int32_t transId) { LOG_SCE_TRACE("(transId=%d)", transId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupSetTimeout(int32_t ctxId, usecond_t timeout) { LOG_SCE_TRACE("(ctxId=%d, timeout=%d)", ctxId, timeout); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (timeout > 10000000) // 10 seconds { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupAbortTransaction(int32_t transId) { LOG_SCE_TRACE("(transId=%d)", transId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupWaitAsync(int32_t transId, int32_t* result) { LOG_SCE_TRACE("(transId=%d, result=%d)", transId, result); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupPollAsync(int32_t transId, int32_t* result) { LOG_SCE_TRACE("(transId=%d, result=%d)", transId, result); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupNpId(int32_t transId, const SceNpOnlineId* onlineId, SceNpId* npId, void* option) { LOG_SCE_TRACE("(transId=%d, onlineId=*0x%x, npId=*0x%x, option=*0x%x)", transId, onlineId, npId, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!onlineId || !npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupNpIdAsync(int32_t transId, SceNpOnlineId* onlineId, SceNpId* npId, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, onlineId=*0x%x, npId=*0x%x, prio=%d, option=*0x%x)", transId, onlineId, npId, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!onlineId || !npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupUserProfile(int32_t transId, const SceNpId* npId, SceNpUserInfo* userInfo, SceNpAboutMe* aboutMe, SceNpMyLanguages* languages, SceNpCountryCode* countryCode, SceNpAvatarImage* avatarImage, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupUserProfileAsync(int32_t transId, const SceNpId* npId, SceNpUserInfo* userInfo, SceNpAboutMe* aboutMe, SceNpMyLanguages* languages, SceNpCountryCode* countryCode, SceNpAvatarImage* avatarImage, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupUserProfileWithAvatarSize(int32_t transId, int32_t avatarSizeType, const SceNpId* npId, SceNpUserInfo* userInfo, SceNpAboutMe* aboutMe, SceNpMyLanguages* languages, SceNpCountryCode* countryCode, void* avatarImageData, uint64_t avatarImageDataMaxSize, uint64_t* avatarImageDataSize, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupUserProfileWithAvatarSizeAsync(int32_t transId, int32_t avatarSizeType, const SceNpId* npId, SceNpUserInfo* userInfo, SceNpAboutMe* aboutMe, SceNpMyLanguages* languages, SceNpCountryCode* countryCode, void* avatarImageData, uint64_t avatarImageDataMaxSize, uint64_t* avatarImageDataSize, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupAvatarImage(int32_t transId, SceNpAvatarUrl* avatarUrl, SceNpAvatarImage* avatarImage, void* option) { LOG_SCE_TRACE("(transId=%d, avatarUrl=*0x%x, avatarImage=*0x%x, option=*0x%x)", transId, avatarUrl, avatarImage, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!avatarUrl || !avatarImage) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupAvatarImageAsync(int32_t transId, SceNpAvatarUrl* avatarUrl, SceNpAvatarImage* avatarImage, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, avatarUrl=*0x%x, avatarImage=*0x%x, prio=%d, option=*0x%x)", transId, avatarUrl, avatarImage, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!avatarUrl || !avatarImage) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupTitleStorage() { UNIMPLEMENTED_FUNC(sceNp); if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupTitleStorageAsync() { UNIMPLEMENTED_FUNC(sceNp); if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupTitleSmallStorage(int32_t transId, void* data, uint64_t maxSize, uint64_t* contentLength, void* option) { LOG_SCE_TRACE("(transId=%d, data=*0x%x, maxSize=%d, contentLength=*0x%x, option=*0x%x)", transId, data, maxSize, contentLength, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!data) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } //if (something > maxSize) //{ // ret = SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE; break; //} if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpLookupTitleSmallStorageAsync(int32_t transId, void* data, uint64_t maxSize, uint64_t* contentLength, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, data=*0x%x, maxSize=%d, contentLength=*0x%x, prio=%d, option=*0x%x)", transId, data, maxSize, contentLength, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!data) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } //if (something > maxSize) //{ // ret = SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE; break; //} if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerRegisterCallback(SceNpManagerCallback* callback, void* arg) { LOG_SCE_TRACE("(callback=*0x%x, arg=*0x%x)", callback, arg); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!callback) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerUnregisterCallback() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetStatus(int32_t* status) { LOG_SCE_TRACE("(status=*0x%x)", status); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!status) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } *status = g_psn_connection_status; ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetNetworkTime(CellRtcTick* pTick) { LOG_SCE_TRACE("(pTick=*0x%x)", pTick); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!pTick) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } // FIXME: Get the network time auto now = std::chrono::system_clock::now(); pTick->tick = std::chrono::duration_cast(now.time_since_epoch()).count(); ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetOnlineId(SceNpOnlineId* onlineId) { LOG_SCE_TRACE("(onlineId=*0x%x)", onlineId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!onlineId) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetNpId(ppu_thread& ppu, SceNpId* npId) { LOG_SCE_TRACE("(npId=*0x%x)", npId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!npId) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetOnlineName(SceNpOnlineName* onlineName) { LOG_SCE_TRACE("(onlineName=*0x%x)", onlineName); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!onlineName) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetAvatarUrl(SceNpAvatarUrl* avatarUrl) { LOG_SCE_TRACE("(avatarUrl=*0x%x)", avatarUrl); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!avatarUrl) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetMyLanguages(SceNpMyLanguages* myLanguages) { LOG_SCE_TRACE("(myLanguages=*0x%x)", myLanguages); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!myLanguages) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetAccountRegion(SceNpCountryCode* countryCode, int32_t* language) { LOG_SCE_TRACE("(countryCode=*0x%x, language=*0x%x)", countryCode, language); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!countryCode || !language) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetAccountAge(int32_t* age) { LOG_SCE_TRACE("(age=*0x%x)", age); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!age) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetContentRatingFlag(int32_t* isRestricted, int32_t* age) { LOG_SCE_TRACE("(isRestricted=*0x%x, age=*0x%x)", isRestricted, age); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!isRestricted || !age) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } // TODO: read user's parental control information *isRestricted = 0; *age = 18; ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetChatRestrictionFlag(int32_t* isRestricted) { LOG_SCE_TRACE("(isRestricted=*0x%x)", isRestricted); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!isRestricted) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } // TODO: read user's parental control information *isRestricted = 0; ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetCachedInfo(CellSysutilUserId userId, SceNpManagerCacheParam* param) { LOG_SCE_TRACE("(userId=%d, param=*0x%x)", userId, param); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!param) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetPsHandle() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpManagerRequestTicket(const SceNpId* npId, const char* serviceId, const void* cookie, uint32_t cookieSize, const char* entitlementId, uint32_t consumedCount) { LOG_SCE_TRACE("(npId=*0x%x, serviceId=%s, cookie=*0x%x, cookieSize=%d, entitlementId=%s, consumedCount=%d)", npId, serviceId, cookie, cookieSize, entitlementId, consumedCount); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!serviceId || !cookie || cookieSize > SCE_NP_COOKIE_MAX_SIZE || !entitlementId) { ret = SCE_NP_AUTH_EINVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerRequestTicket2(const SceNpId* npId, const SceNpTicketVersion* version, const char* serviceId, const void* cookie, uint32_t cookieSize, const char* entitlementId, uint32_t consumedCount) { LOG_SCE_TRACE("(npId=*0x%x, version=*0x%x, serviceId=%s, cookie=*0x%x, cookieSize=%d, entitlementId=%s, consumedCount=%d)", npId, version, serviceId, cookie, cookieSize, entitlementId, consumedCount); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!serviceId || !cookie || cookieSize > SCE_NP_COOKIE_MAX_SIZE || !entitlementId) { ret = SCE_NP_AUTH_EINVALID_ARGUMENT; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = not_an_error(SCE_NP_ERROR_OFFLINE); break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_LOGGING_IN && g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_ERROR_INVALID_STATE; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetTicket(void* buffer, uint32_t* bufferSize) { LOG_SCE_TRACE("(buffer=*0x%x, bufferSize=*0x%x)", buffer, bufferSize); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!bufferSize) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetTicketParam(int32_t paramId, SceNpTicketParam* param) { LOG_SCE_TRACE("(paramId=%d, param=*0x%x)", paramId, param); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!param) { // TODO: check paramId ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetEntitlementIdList(SceNpEntitlementId* entIdList, uint32_t entIdListNum) { LOG_SCE_TRACE("(entIdList=*0x%x, entIdListNum=%d)", entIdList, entIdListNum); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetEntitlementById(const char* entId, SceNpEntitlement* ent) { LOG_SCE_TRACE("(entId=%s, ent=*0x%x)", entId, ent); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!entId) { ret = SCE_NP_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerGetSigninId() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpManagerSubSignin(CellSysutilUserId userId, SceNpManagerSubSigninCallback* cb_func, void* cb_arg, int32_t flag) { LOG_SCE_TRACE("(userId=%d, cb_func=*0x%x, cb_arg=*0x%x, flag=%d)", userId, cb_func, cb_arg, flag); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpManagerSubSigninAbortGui() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpManagerSubSignout(SceNpId* npId) { LOG_SCE_TRACE("(npId=*0x%x)", npId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpMatchingCreateCtx(SceNpId* npId, SceNpMatchingHandler* handler, void* arg, uint32_t* ctx_id) { LOG_SCE_TRACE("(npId=*0x%x, handler=*0x%x, arg=*0x%x, ctx_id=*0x%x)", npId, handler, arg, ctx_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingDestroyCtx(uint32_t ctx_id) { LOG_SCE_TRACE("(ctx_id=%d)", ctx_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetResult(uint32_t ctx_id, uint32_t req_id, void* buf, uint64_t* size, int32_t* event) { LOG_SCE_TRACE("(ctx_id=%d, req_id=%d, buf=*0x%x, size=*0x%x, event=*0x%x)", ctx_id, req_id, buf, size, event); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetResultGUI(void* buf, uint64_t* size, int32_t* event) { LOG_SCE_TRACE("(buf=*0x%x, size=*0x%x, event=*0x%x)", buf, size, event); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingSetRoomInfo(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, SceNpMatchingAttr* attr, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingSetRoomInfoNoLimit(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, SceNpMatchingAttr* attr, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetRoomInfo(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, SceNpMatchingAttr* attr, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetRoomInfoNoLimit(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, SceNpMatchingAttr* attr, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingSetRoomSearchFlag(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, int32_t flag, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetRoomSearchFlag(uint32_t ctx_id, SceNpLobbyId* lobby_id, SceNpRoomId* room_id, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, lobby_id=*0x%x, room_id=*0x%x, req_id=*0x%x)", ctx_id, lobby_id, room_id, req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetRoomMemberListLocal(uint32_t ctx_id, SceNpRoomId* room_id, uint64_t* buflen, void* buf) { LOG_SCE_TRACE("(ctx_id=%d, room_id=*0x%x, buflen=*0x%x, buf=*0x%x)", ctx_id, room_id, buflen, buf); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGetRoomListLimitGUI(uint32_t ctx_id, SceNpCommunicationId* communicationId, SceNpMatchingReqRange* range, SceNpMatchingSearchCondition* cond, SceNpMatchingAttr* attr, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingKickRoomMember(uint32_t ctx_id, const SceNpRoomId* room_id, const SceNpId* user_id, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, room_id=*0x%x, user_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, user_id, req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingKickRoomMemberWithOpt(uint32_t ctx_id, const SceNpRoomId* room_id, const SceNpId* user_id, const void* opt, int32_t opt_len, uint32_t* req_id) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingQuickMatchGUI(uint32_t ctx_id, const SceNpCommunicationId* communicationId, const SceNpMatchingSearchCondition* cond, int32_t available_num, int32_t timeout, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingSendInvitationGUI(uint32_t ctx_id, const SceNpRoomId* room_id, const SceNpCommunicationId* communicationId, const SceNpId* dsts, int32_t num, int32_t slot_type, const char* subject, const char* body, sys_memory_container_t container, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingAcceptInvitationGUI(uint32_t ctx_id, const SceNpCommunicationId* communicationId, sys_memory_container_t container, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(ctx_id=%d, communicationId=*0x%x, container=%d, handler=*0x%x, arg=*0x%x)", ctx_id, communicationId, container, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingCreateRoomGUI(uint32_t ctx_id, const SceNpCommunicationId* communicationId, const SceNpMatchingAttr* attr, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(ctx_id=%d, communicationId=*0x%x, attr=*0x%x, handler=*0x%x, arg=*0x%x)", ctx_id, communicationId, attr, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingJoinRoomGUI(uint32_t ctx_id, SceNpRoomId* room_id, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(ctx_id=%d, room_id=*0x%x, handler=*0x%x, arg=*0x%x)", ctx_id, room_id, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingLeaveRoom(uint32_t ctx_id, const SceNpRoomId* room_id, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, room_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingSearchJoinRoomGUI(uint32_t ctx_id, const SceNpCommunicationId* communicationId, const SceNpMatchingSearchCondition* cond, const SceNpMatchingAttr* attr, SceNpMatchingGUIHandler* handler, void* arg) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpMatchingGrantOwnership(uint32_t ctx_id, const SceNpRoomId* room_id, const SceNpId* user_id, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, room_id=*0x%x, user_id=*0x%x, req_id=*0x%x)", ctx_id, room_id, user_id, req_id); int ret = SCE_ERROR_UNKNOWN; do { ret = SCE_OK; } while(false); return ret; } int sceNpProfileCallGui(const SceNpId* npid, SceNpProfileResultHandler* handler, void* userArg, uint64_t options) { LOG_SCE_TRACE("(npid=*0x%x, handler=*0x%x, userArg=*0x%x, options=0x%x)", npid, handler, userArg, options); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } if (!handler) { ret = SCE_NP_PROFILE_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpProfileAbortGui() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreInit() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { const auto score_manager = g_fxo->get(); if (score_manager->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED; break; } if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } score_manager->is_initialized = true; ret = SCE_OK; } while(false); return ret; } int sceNpScoreTerm() { LOG_SCE_TRACE("()"); int ret = SCE_ERROR_UNKNOWN; do { const auto score_manager = g_fxo->get(); if (!score_manager->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!g_fxo->get()->is_initialized) { ret = SCE_NP_ERROR_NOT_INITIALIZED; break; } score_manager->is_initialized = false; ret = SCE_OK; } while(false); return ret; } int sceNpScoreCreateTitleCtx(const SceNpCommunicationId* communicationId, const SceNpCommunicationPassphrase* passphrase, const SceNpId* selfNpId) { LOG_SCE_TRACE("(communicationId=*0x%x, passphrase=*0x%x, selfNpId=*0x%x)", communicationId, passphrase, selfNpId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!communicationId || !passphrase || !selfNpId) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreDestroyTitleCtx(int32_t titleCtxId) { LOG_SCE_TRACE("(titleCtxId=%d)", titleCtxId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreCreateTransactionCtx(int32_t titleCtxId) { LOG_SCE_TRACE("(titleCtxId=%d)", titleCtxId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (g_psn_connection_status == SCE_NP_MANAGER_STATUS_OFFLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreDestroyTransactionCtx(int32_t transId) { LOG_SCE_TRACE("(transId=%d)", transId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreSetTimeout(int32_t ctxId, usecond_t timeout) { LOG_SCE_TRACE("(ctxId=%d, timeout=%d)", ctxId, timeout); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (timeout > 10000000) // 10 seconds { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreSetPlayerCharacterId(int32_t ctxId, SceNpScorePcId pcId) { LOG_SCE_TRACE("(ctxId=%d, pcId=%d)", ctxId, pcId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (pcId < 0) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreWaitAsync(int32_t transId, int32_t* result) { LOG_SCE_TRACE("(transId=%d, result=*0x%x)", transId, result); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (transId <= 0) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScorePollAsync(int32_t transId, int32_t* result) { LOG_SCE_TRACE("(transId=%d, result=*0x%x)", transId, result); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (transId <= 0) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetBoardInfo(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, void* option) { LOG_SCE_TRACE("(transId=%d, boardId=%d, boardInfo=*0x%x, option=*0x%x)", transId, boardId, boardInfo, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!boardInfo) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetBoardInfoAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreBoardInfo* boardInfo, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, boardId=%d, boardInfo=*0x%x, prio=%d, option=*0x%x)", transId, boardId, boardInfo, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreRecordScore(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment, const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, SceNpScoreRecordOptParam* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreRecordScoreAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreValue score, const SceNpScoreComment* scoreComment, const SceNpScoreGameInfo* gameInfo, SceNpScoreRankNumber* tmpRank, int32_t prio, SceNpScoreRecordOptParam* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreRecordGameData(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreValue score, uint64_t totalSize, uint64_t sendSize, const void* data, void* option) { LOG_SCE_TRACE("(transId=%d, boardId=%d, score=%d, totalSize=%d, sendSize=%d, data=*0x%x, option=*0x%x)", transId, boardId, score, totalSize, sendSize, data, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!data) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreRecordGameDataAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreValue score, uint64_t totalSize, uint64_t sendSize, const void* data, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetGameData(int32_t transId, SceNpScoreBoardId boardId, const SceNpId* npId, uint64_t* totalSize, uint64_t recvSize, void* data, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId || !totalSize || !data) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetGameDataAsync(int32_t transId, SceNpScoreBoardId boardId, const SceNpId* npId, uint64_t* totalSize, uint64_t recvSize, void* data, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByNpId(int32_t transId, SceNpScoreBoardId boardId, const SceNpId* npIdArray, uint64_t npIdArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npIdArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByNpIdAsync(int32_t transId, SceNpScoreBoardId boardId, const SceNpId* npIdArray, uint64_t npIdArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npIdArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByRange(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByRangeAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetFriendsRanking(int32_t transId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!rankArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetFriendsRankingAsync(int32_t transId, SceNpScoreBoardId boardId, int32_t includeSelf, SceNpScoreRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!rankArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreCensorComment(int32_t transId, const char* comment, void* option) { LOG_SCE_TRACE("(transId=%d, comment=%s, option=*0x%x)", transId, comment, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!comment) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } 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 ? ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreCensorCommentAsync(int32_t transId, const char* comment, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, comment=%s, prio=%d, option=*0x%x)", transId, comment, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!comment) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } 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 ? ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreSanitizeComment(int32_t transId, const char* comment, char* sanitizedComment, void* option) { LOG_SCE_TRACE("(transId=%d, comment=%s, sanitizedComment=*0x%x, option=*0x%x)", transId, comment, sanitizedComment, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!comment) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } 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 ? ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreSanitizeCommentAsync(int32_t transId, const char* comment, char* sanitizedComment, int32_t prio, void* option) { LOG_SCE_TRACE("(transId=%d, comment=%s, sanitizedComment=*0x%x, prio=%d, option=*0x%x)", transId, comment, sanitizedComment, prio, option); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!comment) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } 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 ? ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByNpIdPcId(int32_t transId, SceNpScoreBoardId boardId, const SceNpScoreNpIdPcId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetRankingByNpIdPcIdAsync(int32_t transId, SceNpScoreBoardId boardId, const SceNpScoreNpIdPcId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, void* infoArray, uint64_t infoArraySize, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreAbortTransaction(int32_t transId) { LOG_SCE_TRACE("(transId=%d)", transId); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByNpId(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, const SceNpId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByNpIdAsync(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, const SceNpId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByNpIdPcId(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, const SceNpId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByNpIdPcIdAsync(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, const SceNpId* idArray, uint64_t idArraySize, SceNpScorePlayerRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!idArray || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansRankingByRange(int32_t transId, SceNpScoreClansBoardId clanBoardId, SceNpScoreRankNumber startSerialRank, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, void* reserved1, uint64_t reservedSize1, void* reserved2, uint64_t reservedSize2, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_CLAN_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansRankingByRangeAsync(int32_t transId, SceNpScoreClansBoardId clanBoardId, SceNpScoreRankNumber startSerialRank, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, void* reserved1, uint64_t reservedSize1, void* reserved2, uint64_t reservedSize2, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClanMemberGameData(int32_t transId, SceNpScoreBoardId boardId, SceNpClanId clanId, const SceNpId* npId, uint64_t* totalSize, uint64_t recvSize, void* data, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!npId || !totalSize || !data) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClanMemberGameDataAsync(int32_t transId, SceNpScoreBoardId boardId, SceNpClanId clanId, const SceNpId* npId, uint64_t* totalSize, uint64_t recvSize, void* data, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansRankingByClanId(int32_t transId, SceNpScoreClansBoardId clanBoardId, const SceNpClanId* clanIdArray, uint64_t clanIdArraySize, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, void* reserved1, uint64_t reservedSize1, void* reserved2, uint64_t reservedSize2, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!clanIdArray || !rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansRankingByClanIdAsync(int32_t transId, SceNpScoreClansBoardId clanBoardId, const SceNpClanId* clanIdArray, uint64_t clanIdArraySize, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, void* reserved1, uint64_t reservedSize1, void* reserved2, uint64_t reservedSize2, uint64_t arrayNum, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (reserved1 || reservedSize1 || reserved2 || reservedSize2 || option) // reserved and option checks at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByRange(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!rankArray || !totalRecord || !lastSortDate || !arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } if (arrayNum > SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS) { ret = SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE; break; } if (g_psn_connection_status != SCE_NP_MANAGER_STATUS_ONLINE) { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID; break; } ret = SCE_OK; } while(false); return ret; } int sceNpScoreGetClansMembersRankingByRangeAsync(int32_t transId, SceNpClanId clanId, SceNpScoreBoardId boardId, SceNpScoreRankNumber startSerialRank, SceNpScoreClanIdRankData* rankArray, uint64_t rankArraySize, SceNpScoreComment* commentArray, uint64_t commentArraySize, SceNpScoreGameInfo* infoArray, uint64_t infoArraySize, SceNpScoreClansMemberDescription* descriptArray, uint64_t descriptArraySize, uint64_t arrayNum, SceNpScoreClanBasicInfo* clanInfo, CellRtcTick* lastSortDate, SceNpScoreRankNumber* totalRecord, int32_t prio, void* option) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED; break; } if (!arrayNum) { ret = SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT; break; } if (!startSerialRank || option) // option check at least until fw 4.71 { ret = SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingCreateCtx(SceNpId* npId, SceNpSignalingHandler* handler, void* arg, uint32_t* ctx_id) { LOG_SCE_TRACE("(npId=*0x%x, handler=*0x%x, arg=*0x%x, ctx_id=*0x%x)", npId, handler, arg, ctx_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!npId || !ctx_id) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } //if (current_contexts > SCE_NP_SIGNALING_CTX_MAX) //{ // ret = SCE_NP_SIGNALING_ERROR_CTX_MAX; break; //} ret = SCE_OK; } while(false); return ret; } int sceNpSignalingDestroyCtx(uint32_t ctx_id) { LOG_SCE_TRACE("(ctx_id=%d)", ctx_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingAddExtendedHandler(uint32_t ctx_id, SceNpSignalingHandler* handler, void* arg) { LOG_SCE_TRACE("(ctx_id=%d, handler=*0x%x, arg=*0x%x)", ctx_id, handler, arg); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingSetCtxOpt(uint32_t ctx_id, int32_t optname, int32_t optval) { LOG_SCE_TRACE("(ctx_id=%d, optname=%d, optval=%d)", ctx_id, optname, optval); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!optname || !optval) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetCtxOpt(uint32_t ctx_id, int32_t optname, int32_t* optval) { LOG_SCE_TRACE("(ctx_id=%d, optname=%d, optval=*0x%x)", ctx_id, optname, optval); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!optname || !optval) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingActivateConnection(uint32_t ctx_id, SceNpId* npId, uint32_t conn_id) { LOG_SCE_TRACE("(ctx_id=%d, npId=*0x%x, conn_id=%d)", ctx_id, npId, conn_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!npId || !conn_id) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingDeactivateConnection(uint32_t ctx_id, uint32_t conn_id) { LOG_SCE_TRACE("(ctx_id=%d, conn_id=%d)", ctx_id, conn_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingTerminateConnection(uint32_t ctx_id, uint32_t conn_id) { LOG_SCE_TRACE("(ctx_id=%d, conn_id=%d)", ctx_id, conn_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetConnectionStatus(uint32_t ctx_id, uint32_t conn_id, int32_t* conn_status, in_addr* peer_addr, in_port_t* peer_port) { LOG_SCE_TRACE("(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); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!conn_status) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetConnectionInfo(uint32_t ctx_id, uint32_t conn_id, int32_t code, SceNpSignalingConnectionInfo* info) { LOG_SCE_TRACE("(ctx_id=%d, conn_id=%d, code=%d, info=*0x%x)", ctx_id, conn_id, code, info); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!info) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetConnectionFromNpId(uint32_t ctx_id, SceNpId* npId, uint32_t* conn_id) { LOG_SCE_TRACE("(ctx_id=%d, npId=*0x%x, conn_id=*0x%x)", ctx_id, npId, conn_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!npId || !conn_id) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetConnectionFromPeerAddress(uint32_t ctx_id, in_addr* peer_addr, in_port_t peer_port, uint32_t* conn_id) { LOG_SCE_TRACE("(ctx_id=%d, peer_addr=*0x%x, peer_port=%d, conn_id=*0x%x)", ctx_id, peer_addr, peer_port, conn_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!conn_id) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetLocalNetInfo(uint32_t ctx_id, SceNpSignalingNetInfo* info) { LOG_SCE_TRACE("(ctx_id=%d, info=*0x%x)", ctx_id, info); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!info) { // TODO: check info->size ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetPeerNetInfo(uint32_t ctx_id, SceNpId* npId, uint32_t* req_id) { LOG_SCE_TRACE("(ctx_id=%d, npId=*0x%x, req_id=*0x%x)", ctx_id, npId, req_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!npId || !req_id) { ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingCancelPeerNetInfo(uint32_t ctx_id, uint32_t req_id) { LOG_SCE_TRACE("(ctx_id=%d, req_id=%d)", ctx_id, req_id); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } ret = SCE_OK; } while(false); return ret; } int sceNpSignalingGetPeerNetInfoResult(uint32_t ctx_id, uint32_t req_id, SceNpSignalingNetInfo* info) { LOG_SCE_TRACE("(ctx_id=%d, req_id=%d, info=*0x%x)", ctx_id, req_id, info); int ret = SCE_ERROR_UNKNOWN; do { if (!g_fxo->get()->is_initialized) { ret = SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED; break; } if (!info) { // TODO: check info->size ret = SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT; break; } ret = SCE_OK; } while(false); return ret; } int sceNpUtilCanonicalizeNpIdForPs3() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpUtilCanonicalizeNpIdForPsp() { UNIMPLEMENTED_FUNC(sceNp); ret = SCE_OK; } while(false); return ret; } int sceNpUtilCmpNpId(SceNpId* id1, SceNpId* id2) { LOG_SCE_TRACE("(id1=*0x%x, id2=*0x%x)", id1, id2); int ret = SCE_ERROR_UNKNOWN; do { if (!id1 || !id2) { ret = SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; break; } // Unknown what this constant means if (id1->reserved[0] != 1 || id2->reserved[0] != 1) { ret = SCE_NP_UTIL_ERROR_INVALID_NP_ID; break; } if (strncmp(id1->handle.data, id2->handle.data, 16) || id1->unk1[0] != id2->unk1[0]) { ret = SCE_NP_UTIL_ERROR_NOT_MATCH; break; } if (id1->unk1[1] != id2->unk1[1]) { // If either is zero they match if (id1->opt[4] && id2->opt[4]) { ret = SCE_NP_UTIL_ERROR_NOT_MATCH; break; } } ret = SCE_OK; } while(false); return ret; } int sceNpUtilCmpNpIdInOrder(const SceNpId* id1, const SceNpId* id2, int32_t* order) { LOG_SCE_TRACE("(id1=*0x%x, id2=*0x%x, order=*0x%x)", id1, id2, order); int ret = SCE_ERROR_UNKNOWN; do { if (!id1 || !id2) { ret = SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; break; } if (id1->reserved[0] != 1 || id2->reserved[0] != 1) { ret = SCE_NP_UTIL_ERROR_INVALID_NP_ID; break; } if (s32 res = strncmp(id1->handle.data, id2->handle.data, 16)) { *order = std::clamp(res, -1, 1); ret = SCE_OK; } while(false); return ret; } if (s32 res = memcmp(id1->unk1, id2->unk1, 4)) { *order = std::clamp(res, -1, 1); ret = SCE_OK; } while(false); return ret; } const u8 opt14 = id1->opt[4]; const u8 opt24 = id2->opt[4]; if (opt14 == 0 && opt24 == 0) { *order = 0; ret = SCE_OK; } while(false); return ret; } if (opt14 != 0 && opt24 != 0) { s32 res = memcmp(id1->unk1 + 1, id2->unk1 + 1, 4); *order = std::clamp(res, -1, 1); ret = SCE_OK; } while(false); return ret; } s32 res = memcmp((opt14 != 0 ? id1 : id2)->unk1 + 1, "ps3", 4); *order = std::clamp(res, -1, 1); ret = SCE_OK; } while(false); return ret; } int sceNpUtilCmpOnlineId(const SceNpId* id1, const SceNpId* id2) { LOG_SCE_TRACE("(id1=*0x%x, id2=*0x%x)", id1, id2); int ret = SCE_ERROR_UNKNOWN; do { if (!id1 || !id2) { ret = SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; break; } if (id1->reserved[0] != 1 || id2->reserved[0] != 1) { ret = SCE_NP_UTIL_ERROR_INVALID_NP_ID; break; } if (strncmp(id1->handle.data, id2->handle.data, 16) != 0) { ret = SCE_NP_UTIL_ERROR_NOT_MATCH; break; } ret = SCE_OK; } while(false); return ret; } int sceNpUtilGetPlatformType(const SceNpId* npId) { LOG_SCE_TRACE("(npId=*0x%x)", npId); int ret = SCE_ERROR_UNKNOWN; do { if (!npId) { ret = SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; break; } switch (npId->unk1[1]) { case "ps4\0"_u32: ret = not_an_error(SCE_NP_PLATFORM_TYPE_PS4); break; case "psp2"_u32: ret = not_an_error(SCE_NP_PLATFORM_TYPE_VITA); break; case "ps3\0"_u32: ret = not_an_error(SCE_NP_PLATFORM_TYPE_PS3); break; case 0u: ret = not_an_error(SCE_NP_PLATFORM_TYPE_NONE); break; default: break; } ret = SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE; break; } int sceNpUtilSetPlatformType(SceNpId* npId, SceNpPlatformType platformType) { LOG_SCE_TRACE("(npId=*0x%x, platformType=%d)", npId, platformType); int ret = SCE_ERROR_UNKNOWN; do { if (!npId) { ret = SCE_NP_UTIL_ERROR_INVALID_ARGUMENT; break; } switch (platformType) { case SCE_NP_PLATFORM_TYPE_PS4: npId->unk1[1] = "ps4\0"_u32; break; case SCE_NP_PLATFORM_TYPE_VITA: npId->unk1[1] = "psp2"_u32; break; case SCE_NP_PLATFORM_TYPE_PS3: npId->unk1[1] = "ps3\0"_u32; break; case SCE_NP_PLATFORM_TYPE_NONE: npId->unk1[1] = 0; break; default: ret = SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE; break; } ret = SCE_OK; } while(false); return ret; } error_code _sceNpSysutilClientMalloc() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } error_code _sceNpSysutilClientFree() { UNIMPLEMENTED_FUNC(sceNp); return CELL_OK; } s32 _Z33_sce_np_sysutil_send_empty_packetiPN16sysutil_cxmlutil11FixedMemoryEPKcS3_() { sceNp.todo("_Z33_sce_np_sysutil_send_empty_packetiPN16sysutil_cxmlutil11FixedMemoryEPKcS3_()"); return CELL_OK; } s32 _Z27_sce_np_sysutil_send_packetiRN4cxml8DocumentE() { sceNp.todo("_Z27_sce_np_sysutil_send_packetiRN4cxml8DocumentE()"); return CELL_OK; } s32 _Z36_sce_np_sysutil_recv_packet_fixedmemiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE() { sceNp.todo("_Z36_sce_np_sysutil_recv_packet_fixedmemiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE()"); return CELL_OK; } s32 _Z40_sce_np_sysutil_recv_packet_fixedmem_subiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE() { sceNp.todo("_Z40_sce_np_sysutil_recv_packet_fixedmem_subiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE()"); return CELL_OK; } s32 _Z27_sce_np_sysutil_recv_packetiRN4cxml8DocumentERNS_7ElementE() { sceNp.todo("_Z27_sce_np_sysutil_recv_packetiRN4cxml8DocumentERNS_7ElementE()"); return CELL_OK; } s32 _Z29_sce_np_sysutil_cxml_set_npidRN4cxml8DocumentERNS_7ElementEPKcPK7SceNpId() { sceNp.todo("_Z29_sce_np_sysutil_cxml_set_npidRN4cxml8DocumentERNS_7ElementEPKcPK7SceNpId()"); return CELL_OK; } s32 _Z31_sce_np_sysutil_send_packet_subiRN4cxml8DocumentE() { sceNp.todo("_Z31_sce_np_sysutil_send_packet_subiRN4cxml8DocumentE()"); return CELL_OK; } s32 _Z37sce_np_matching_set_matching2_runningb() { sceNp.todo("_Z37sce_np_matching_set_matching2_runningb()"); return CELL_OK; } s32 _Z32_sce_np_sysutil_cxml_prepare_docPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentEPKcRNS2_7ElementES6_i() { sceNp.todo("_Z32_sce_np_sysutil_cxml_prepare_docPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentEPKcRNS2_7ElementES6_i()"); return CELL_OK; } DECLARE(ppu_module_manager::sceNp)("sceNp", []() { REG_FUNC(sceNp, sceNpInit); REG_FUNC(sceNp, sceNpTerm); REG_FUNC(sceNp, sceNpDrmIsAvailable); REG_FUNC(sceNp, sceNpDrmIsAvailable2); REG_FUNC(sceNp, sceNpDrmVerifyUpgradeLicense); REG_FUNC(sceNp, sceNpDrmVerifyUpgradeLicense2); REG_FUNC(sceNp, sceNpDrmExecuteGamePurchase); REG_FUNC(sceNp, sceNpDrmGetTimelimit); REG_FUNC(sceNp, sceNpDrmProcessExitSpawn); REG_FUNC(sceNp, sceNpDrmProcessExitSpawn2); REG_FUNC(sceNp, sceNpBasicRegisterHandler); REG_FUNC(sceNp, sceNpBasicRegisterContextSensitiveHandler); REG_FUNC(sceNp, sceNpBasicUnregisterHandler); REG_FUNC(sceNp, sceNpBasicSetPresence); REG_FUNC(sceNp, sceNpBasicSetPresenceDetails); REG_FUNC(sceNp, sceNpBasicSetPresenceDetails2); REG_FUNC(sceNp, sceNpBasicSendMessage); REG_FUNC(sceNp, sceNpBasicSendMessageGui); REG_FUNC(sceNp, sceNpBasicSendMessageAttachment); REG_FUNC(sceNp, sceNpBasicRecvMessageAttachment); REG_FUNC(sceNp, sceNpBasicRecvMessageAttachmentLoad); REG_FUNC(sceNp, sceNpBasicRecvMessageCustom); REG_FUNC(sceNp, sceNpBasicMarkMessageAsUsed); REG_FUNC(sceNp, sceNpBasicAbortGui); REG_FUNC(sceNp, sceNpBasicAddFriend); REG_FUNC(sceNp, sceNpBasicGetFriendListEntryCount); REG_FUNC(sceNp, sceNpBasicGetFriendListEntry); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByIndex); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByIndex2); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByNpId); REG_FUNC(sceNp, sceNpBasicGetFriendPresenceByNpId2); REG_FUNC(sceNp, sceNpBasicAddPlayersHistory); REG_FUNC(sceNp, sceNpBasicAddPlayersHistoryAsync); REG_FUNC(sceNp, sceNpBasicGetPlayersHistoryEntryCount); REG_FUNC(sceNp, sceNpBasicGetPlayersHistoryEntry); REG_FUNC(sceNp, sceNpBasicAddBlockListEntry); REG_FUNC(sceNp, sceNpBasicGetBlockListEntryCount); REG_FUNC(sceNp, sceNpBasicGetBlockListEntry); REG_FUNC(sceNp, sceNpBasicGetMessageAttachmentEntryCount); REG_FUNC(sceNp, sceNpBasicGetMessageAttachmentEntry); REG_FUNC(sceNp, sceNpBasicGetCustomInvitationEntryCount); REG_FUNC(sceNp, sceNpBasicGetCustomInvitationEntry); REG_FUNC(sceNp, sceNpBasicGetMatchingInvitationEntryCount); REG_FUNC(sceNp, sceNpBasicGetMatchingInvitationEntry); REG_FUNC(sceNp, sceNpBasicGetClanMessageEntryCount); REG_FUNC(sceNp, sceNpBasicGetClanMessageEntry); REG_FUNC(sceNp, sceNpBasicGetMessageEntryCount); REG_FUNC(sceNp, sceNpBasicGetMessageEntry); REG_FUNC(sceNp, sceNpBasicGetEvent); REG_FUNC(sceNp, sceNpCommerceCreateCtx); REG_FUNC(sceNp, sceNpCommerceDestroyCtx); REG_FUNC(sceNp, sceNpCommerceInitProductCategory); REG_FUNC(sceNp, sceNpCommerceDestroyProductCategory); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryStart); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryFinish); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryResult); REG_FUNC(sceNp, sceNpCommerceGetProductCategoryAbort); REG_FUNC(sceNp, sceNpCommerceGetProductId); REG_FUNC(sceNp, sceNpCommerceGetProductName); REG_FUNC(sceNp, sceNpCommerceGetCategoryDescription); REG_FUNC(sceNp, sceNpCommerceGetCategoryId); REG_FUNC(sceNp, sceNpCommerceGetCategoryImageURL); REG_FUNC(sceNp, sceNpCommerceGetCategoryInfo); REG_FUNC(sceNp, sceNpCommerceGetCategoryName); REG_FUNC(sceNp, sceNpCommerceGetCurrencyCode); REG_FUNC(sceNp, sceNpCommerceGetCurrencyDecimals); REG_FUNC(sceNp, sceNpCommerceGetCurrencyInfo); REG_FUNC(sceNp, sceNpCommerceGetNumOfChildCategory); REG_FUNC(sceNp, sceNpCommerceGetNumOfChildProductSku); REG_FUNC(sceNp, sceNpCommerceGetSkuDescription); REG_FUNC(sceNp, sceNpCommerceGetSkuId); REG_FUNC(sceNp, sceNpCommerceGetSkuImageURL); REG_FUNC(sceNp, sceNpCommerceGetSkuName); REG_FUNC(sceNp, sceNpCommerceGetSkuPrice); REG_FUNC(sceNp, sceNpCommerceGetSkuUserData); REG_FUNC(sceNp, sceNpCommerceSetDataFlagStart); REG_FUNC(sceNp, sceNpCommerceGetDataFlagStart); REG_FUNC(sceNp, sceNpCommerceSetDataFlagFinish); REG_FUNC(sceNp, sceNpCommerceGetDataFlagFinish); REG_FUNC(sceNp, sceNpCommerceGetDataFlagState); REG_FUNC(sceNp, sceNpCommerceGetDataFlagAbort); REG_FUNC(sceNp, sceNpCommerceGetChildCategoryInfo); REG_FUNC(sceNp, sceNpCommerceGetChildProductSkuInfo); REG_FUNC(sceNp, sceNpCommerceDoCheckoutStartAsync); REG_FUNC(sceNp, sceNpCommerceDoCheckoutFinishAsync); REG_FUNC(sceNp, sceNpCustomMenuRegisterActions); REG_FUNC(sceNp, sceNpCustomMenuActionSetActivation); REG_FUNC(sceNp, sceNpCustomMenuRegisterExceptionList); REG_FUNC(sceNp, sceNpFriendlist); REG_FUNC(sceNp, sceNpFriendlistCustom); REG_FUNC(sceNp, sceNpFriendlistAbortGui); REG_FUNC(sceNp, sceNpLookupInit); REG_FUNC(sceNp, sceNpLookupTerm); REG_FUNC(sceNp, sceNpLookupCreateTitleCtx); REG_FUNC(sceNp, sceNpLookupDestroyTitleCtx); REG_FUNC(sceNp, sceNpLookupCreateTransactionCtx); REG_FUNC(sceNp, sceNpLookupDestroyTransactionCtx); REG_FUNC(sceNp, sceNpLookupSetTimeout); REG_FUNC(sceNp, sceNpLookupAbortTransaction); REG_FUNC(sceNp, sceNpLookupWaitAsync); REG_FUNC(sceNp, sceNpLookupPollAsync); REG_FUNC(sceNp, sceNpLookupNpId); REG_FUNC(sceNp, sceNpLookupNpIdAsync); REG_FUNC(sceNp, sceNpLookupUserProfile); REG_FUNC(sceNp, sceNpLookupUserProfileAsync); REG_FUNC(sceNp, sceNpLookupUserProfileWithAvatarSize); REG_FUNC(sceNp, sceNpLookupUserProfileWithAvatarSizeAsync); REG_FUNC(sceNp, sceNpLookupAvatarImage); REG_FUNC(sceNp, sceNpLookupAvatarImageAsync); REG_FUNC(sceNp, sceNpLookupTitleStorage); REG_FUNC(sceNp, sceNpLookupTitleStorageAsync); REG_FUNC(sceNp, sceNpLookupTitleSmallStorage); REG_FUNC(sceNp, sceNpLookupTitleSmallStorageAsync); REG_FUNC(sceNp, sceNpManagerRegisterCallback); REG_FUNC(sceNp, sceNpManagerUnregisterCallback); REG_FUNC(sceNp, sceNpManagerGetStatus); REG_FUNC(sceNp, sceNpManagerGetNetworkTime); REG_FUNC(sceNp, sceNpManagerGetOnlineId); REG_FUNC(sceNp, sceNpManagerGetNpId); REG_FUNC(sceNp, sceNpManagerGetOnlineName); REG_FUNC(sceNp, sceNpManagerGetAvatarUrl); REG_FUNC(sceNp, sceNpManagerGetMyLanguages); REG_FUNC(sceNp, sceNpManagerGetAccountRegion); REG_FUNC(sceNp, sceNpManagerGetAccountAge); REG_FUNC(sceNp, sceNpManagerGetContentRatingFlag); REG_FUNC(sceNp, sceNpManagerGetChatRestrictionFlag); REG_FUNC(sceNp, sceNpManagerGetCachedInfo); REG_FUNC(sceNp, sceNpManagerGetPsHandle); REG_FUNC(sceNp, sceNpManagerRequestTicket); REG_FUNC(sceNp, sceNpManagerRequestTicket2); REG_FUNC(sceNp, sceNpManagerGetTicket); REG_FUNC(sceNp, sceNpManagerGetTicketParam); REG_FUNC(sceNp, sceNpManagerGetEntitlementIdList); REG_FUNC(sceNp, sceNpManagerGetEntitlementById); REG_FUNC(sceNp, sceNpManagerGetSigninId); REG_FUNC(sceNp, sceNpManagerSubSignin); REG_FUNC(sceNp, sceNpManagerSubSigninAbortGui); REG_FUNC(sceNp, sceNpManagerSubSignout); REG_FUNC(sceNp, sceNpMatchingCreateCtx); REG_FUNC(sceNp, sceNpMatchingDestroyCtx); REG_FUNC(sceNp, sceNpMatchingGetResult); REG_FUNC(sceNp, sceNpMatchingGetResultGUI); REG_FUNC(sceNp, sceNpMatchingSetRoomInfo); REG_FUNC(sceNp, sceNpMatchingSetRoomInfoNoLimit); REG_FUNC(sceNp, sceNpMatchingGetRoomInfo); REG_FUNC(sceNp, sceNpMatchingGetRoomInfoNoLimit); REG_FUNC(sceNp, sceNpMatchingSetRoomSearchFlag); REG_FUNC(sceNp, sceNpMatchingGetRoomSearchFlag); REG_FUNC(sceNp, sceNpMatchingGetRoomMemberListLocal); REG_FUNC(sceNp, sceNpMatchingGetRoomListLimitGUI); REG_FUNC(sceNp, sceNpMatchingKickRoomMember); REG_FUNC(sceNp, sceNpMatchingKickRoomMemberWithOpt); REG_FUNC(sceNp, sceNpMatchingQuickMatchGUI); REG_FUNC(sceNp, sceNpMatchingSendInvitationGUI); REG_FUNC(sceNp, sceNpMatchingAcceptInvitationGUI); REG_FUNC(sceNp, sceNpMatchingCreateRoomGUI); REG_FUNC(sceNp, sceNpMatchingJoinRoomGUI); REG_FUNC(sceNp, sceNpMatchingLeaveRoom); REG_FUNC(sceNp, sceNpMatchingSearchJoinRoomGUI); REG_FUNC(sceNp, sceNpMatchingGrantOwnership); REG_FUNC(sceNp, sceNpProfileCallGui); REG_FUNC(sceNp, sceNpProfileAbortGui); REG_FUNC(sceNp, sceNpScoreInit); REG_FUNC(sceNp, sceNpScoreTerm); REG_FUNC(sceNp, sceNpScoreCreateTitleCtx); REG_FUNC(sceNp, sceNpScoreDestroyTitleCtx); REG_FUNC(sceNp, sceNpScoreCreateTransactionCtx); REG_FUNC(sceNp, sceNpScoreDestroyTransactionCtx); REG_FUNC(sceNp, sceNpScoreSetTimeout); REG_FUNC(sceNp, sceNpScoreSetPlayerCharacterId); REG_FUNC(sceNp, sceNpScoreWaitAsync); REG_FUNC(sceNp, sceNpScorePollAsync); REG_FUNC(sceNp, sceNpScoreGetBoardInfo); REG_FUNC(sceNp, sceNpScoreGetBoardInfoAsync); REG_FUNC(sceNp, sceNpScoreRecordScore); REG_FUNC(sceNp, sceNpScoreRecordScoreAsync); REG_FUNC(sceNp, sceNpScoreRecordGameData); REG_FUNC(sceNp, sceNpScoreRecordGameDataAsync); REG_FUNC(sceNp, sceNpScoreGetGameData); REG_FUNC(sceNp, sceNpScoreGetGameDataAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByNpId); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByRange); REG_FUNC(sceNp, sceNpScoreGetRankingByRangeAsync); REG_FUNC(sceNp, sceNpScoreGetFriendsRanking); REG_FUNC(sceNp, sceNpScoreGetFriendsRankingAsync); REG_FUNC(sceNp, sceNpScoreCensorComment); REG_FUNC(sceNp, sceNpScoreCensorCommentAsync); REG_FUNC(sceNp, sceNpScoreSanitizeComment); REG_FUNC(sceNp, sceNpScoreSanitizeCommentAsync); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdPcId); REG_FUNC(sceNp, sceNpScoreGetRankingByNpIdPcIdAsync); REG_FUNC(sceNp, sceNpScoreAbortTransaction); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpId); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdPcId); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByNpIdPcIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByRange); REG_FUNC(sceNp, sceNpScoreGetClansMembersRankingByRangeAsync); REG_FUNC(sceNp, sceNpScoreGetClanMemberGameData); REG_FUNC(sceNp, sceNpScoreGetClanMemberGameDataAsync); REG_FUNC(sceNp, sceNpScoreGetClansRankingByClanId); REG_FUNC(sceNp, sceNpScoreGetClansRankingByClanIdAsync); REG_FUNC(sceNp, sceNpScoreGetClansRankingByRange); REG_FUNC(sceNp, sceNpScoreGetClansRankingByRangeAsync); REG_FUNC(sceNp, sceNpSignalingCreateCtx); REG_FUNC(sceNp, sceNpSignalingDestroyCtx); REG_FUNC(sceNp, sceNpSignalingAddExtendedHandler); REG_FUNC(sceNp, sceNpSignalingSetCtxOpt); REG_FUNC(sceNp, sceNpSignalingGetCtxOpt); REG_FUNC(sceNp, sceNpSignalingActivateConnection); REG_FUNC(sceNp, sceNpSignalingDeactivateConnection); REG_FUNC(sceNp, sceNpSignalingTerminateConnection); REG_FUNC(sceNp, sceNpSignalingGetConnectionStatus); REG_FUNC(sceNp, sceNpSignalingGetConnectionInfo); REG_FUNC(sceNp, sceNpSignalingGetConnectionFromNpId); REG_FUNC(sceNp, sceNpSignalingGetConnectionFromPeerAddress); REG_FUNC(sceNp, sceNpSignalingGetLocalNetInfo); REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfo); REG_FUNC(sceNp, sceNpSignalingCancelPeerNetInfo); REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfoResult); REG_FUNC(sceNp, sceNpUtilCanonicalizeNpIdForPs3); REG_FUNC(sceNp, sceNpUtilCanonicalizeNpIdForPsp); REG_FUNC(sceNp, sceNpUtilCmpNpId); REG_FUNC(sceNp, sceNpUtilCmpNpIdInOrder); REG_FUNC(sceNp, sceNpUtilCmpOnlineId); REG_FUNC(sceNp, sceNpUtilGetPlatformType); REG_FUNC(sceNp, sceNpUtilSetPlatformType); REG_FUNC(sceNp, _sceNpSysutilClientMalloc); REG_FUNC(sceNp, _sceNpSysutilClientFree); REG_FUNC(sceNp, _Z33_sce_np_sysutil_send_empty_packetiPN16sysutil_cxmlutil11FixedMemoryEPKcS3_); REG_FUNC(sceNp, _Z27_sce_np_sysutil_send_packetiRN4cxml8DocumentE); REG_FUNC(sceNp, _Z36_sce_np_sysutil_recv_packet_fixedmemiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE); REG_FUNC(sceNp, _Z40_sce_np_sysutil_recv_packet_fixedmem_subiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE); REG_FUNC(sceNp, _Z27_sce_np_sysutil_recv_packetiRN4cxml8DocumentERNS_7ElementE); REG_FUNC(sceNp, _Z29_sce_np_sysutil_cxml_set_npidRN4cxml8DocumentERNS_7ElementEPKcPK7SceNpId); REG_FUNC(sceNp, _Z31_sce_np_sysutil_send_packet_subiRN4cxml8DocumentE); REG_FUNC(sceNp, _Z37sce_np_matching_set_matching2_runningb); REG_FUNC(sceNp, _Z32_sce_np_sysutil_cxml_prepare_docPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentEPKcRNS2_7ElementES6_i); });