From b36df1383aa724364584d2f3e2357ff22beebf0c Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 29 Mar 2024 23:25:52 +0200 Subject: [PATCH 01/14] added more dummy modules --- CMakeLists.txt | 10 + src/common/logging/filter.cpp | 5 + src/common/logging/types.h | 5 + src/core/hle/libraries/libs.cpp | 10 + src/core/libraries/libscehttp.cpp | 717 +++++++++++++ src/core/libraries/libscehttp.h | 127 +++ src/core/libraries/libscenet.cpp | 1356 +++++++++++++++++++++++++ src/core/libraries/libscenet.h | 231 +++++ src/core/libraries/libscenetctl.cpp | 670 ++++++++++++ src/core/libraries/libscenetctl.h | 105 ++ src/core/libraries/libscesavedata.cpp | 653 ++++++++++++ src/core/libraries/libscesavedata.h | 107 ++ src/core/libraries/libscessl.cpp | 1284 +++++++++++++++++++++++ src/core/libraries/libscessl.h | 220 ++++ 14 files changed, 5500 insertions(+) create mode 100644 src/core/libraries/libscehttp.cpp create mode 100644 src/core/libraries/libscehttp.h create mode 100644 src/core/libraries/libscenet.cpp create mode 100644 src/core/libraries/libscenet.h create mode 100644 src/core/libraries/libscenetctl.cpp create mode 100644 src/core/libraries/libscenetctl.h create mode 100644 src/core/libraries/libscesavedata.cpp create mode 100644 src/core/libraries/libscesavedata.h create mode 100644 src/core/libraries/libscessl.cpp create mode 100644 src/core/libraries/libscessl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 20791c13..63a16126 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -102,8 +102,18 @@ set(LIBRARIES src/core/libraries/library_common.h src/core/libraries/libscecommondialog.h src/core/libraries/libscegnmdriver.cpp src/core/libraries/libscegnmdriver.h + src/core/libraries/libscehttp.cpp + src/core/libraries/libscehttp.h src/core/libraries/libscemsgdialog.cpp src/core/libraries/libscemsgdialog.h + src/core/libraries/libscenet.cpp + src/core/libraries/libscenet.h + src/core/libraries/libscenetctl.cpp + src/core/libraries/libscenetctl.h + src/core/libraries/libscesavedata.cpp + src/core/libraries/libscesavedata.h + src/core/libraries/libscessl.cpp + src/core/libraries/libscessl.h src/core/libraries/libscesystemservice.cpp src/core/libraries/libscesystemservice.h src/core/libraries/libsceuserservice.cpp diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp index fc9c86e4..0ee022de 100644 --- a/src/common/logging/filter.cpp +++ b/src/common/logging/filter.cpp @@ -88,6 +88,11 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) { SUB(Lib, CommonDlg) \ SUB(Lib, MsgDlg) \ SUB(Lib, AudioOut) \ + SUB(Lib, Net) \ + SUB(Lib, NetCtl) \ + SUB(Lib, SaveData) \ + SUB(Lib, Http) \ + SUB(Lib, Ssl) \ CLS(Frontend) \ CLS(Render) \ SUB(Render, Vulkan) \ diff --git a/src/common/logging/types.h b/src/common/logging/types.h index c8f4fbd8..9fa50412 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -55,6 +55,11 @@ enum class Class : u8 { Lib_CommonDlg, ///< The LibSceCommonDialog implementation. Lib_MsgDlg, ///< The LibSceMsgDialog implementation. Lib_AudioOut, ///< The LibSceAudioOut implementation. + Lib_Net, ///< The LibSceNet implementation. + Lib_NetCtl, ///< The LibSecNetCtl implementation. + Lib_SaveData, ///< The LibSceSaveData implementation. + Lib_Ssl, ///< The LibSsl implementation. + Lib_Http, ///< The LibHttp implementation. Frontend, ///< Emulator UI Render, ///< Video Core Render_Vulkan, ///< Vulkan backend diff --git a/src/core/hle/libraries/libs.cpp b/src/core/hle/libraries/libs.cpp index 88184fe9..2c8aedc8 100644 --- a/src/core/hle/libraries/libs.cpp +++ b/src/core/hle/libraries/libs.cpp @@ -10,7 +10,12 @@ #include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h" #include "src/core/libraries/libsceaudioout.h" #include "src/core/libraries/libscecommondialog.h" +#include "src/core/libraries/libscehttp.h" #include "src/core/libraries/libscemsgdialog.h" +#include "src/core/libraries/libscenet.h" +#include "src/core/libraries/libscenetctl.h" +#include "src/core/libraries/libscesavedata.h" +#include "src/core/libraries/libscessl.h" #include "src/core/libraries/libscesystemservice.h" #include "src/core/libraries/libsceuserservice.h" @@ -31,6 +36,11 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) { Libraries::CommonDialog::RegisterlibSceCommonDialog(sym); Libraries::MsgDialog::RegisterlibSceMsgDialog(sym); Libraries::AudioOut::RegisterlibSceAudioOut(sym); + Libraries::Http::RegisterlibSceHttp(sym); + Libraries::Net::RegisterlibSceNet(sym); + Libraries::NetCtl::RegisterlibSceNetCtl(sym); + Libraries::SaveData::RegisterlibSceSaveData(sym); + Libraries::Ssl::RegisterlibSceSsl(sym); } } // namespace OldLibraries diff --git a/src/core/libraries/libscehttp.cpp b/src/core/libraries/libscehttp.cpp new file mode 100644 index 00000000..7d6888d0 --- /dev/null +++ b/src/core/libraries/libscehttp.cpp @@ -0,0 +1,717 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libscehttp.h" + +namespace Libraries::Http { + +int PS4_SYSV_ABI sceHttpAbortRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAbortRequestForce() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAbortWaitRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAddCookie() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAddQuery() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAddRequestHeader() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAuthCacheExport() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAuthCacheFlush() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpAuthCacheImport() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCookieExport() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCookieFlush() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCookieImport() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateConnection() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateConnectionWithURL() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateEpoll() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateRequest2() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateRequestWithURL() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateRequestWithURL2() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpCreateTemplate() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgEnableProfile() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgGetConnectionStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgGetRequestStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgSetPrintf() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgShowConnectionStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgShowRequestStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDbgShowStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDeleteConnection() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDeleteRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDeleteTemplate() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpDestroyEpoll() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetAllResponseHeaders() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetAuthEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetAutoRedirect() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetConnectionStat() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetCookie() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetCookieEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetCookieStats() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetEpoll() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetEpollId() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetLastErrno() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetMemoryPoolStats() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetNonblock() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetResponseContentLength() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpGetStatusCode() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpInit() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpParseResponseHeader() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpParseStatusLine() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpReadData() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpRedirectCacheFlush() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpRemoveRequestHeader() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpRequestGetAllHeaders() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsDisableOption() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsDisableOptionPrivate() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsEnableOption() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsEnableOptionPrivate() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSendRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetAuthEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetAuthInfoCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetAutoRedirect() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetConnectTimeOut() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieMaxNum() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieMaxSize() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieRecvCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieSendCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetEpoll() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetEpollId() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetHttp09Enabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetNonblock() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetPolicyOption() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetPriorityOption() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetProxy() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetRecvBlockSize() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetRecvTimeOut() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetRedirectCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetRequestContentLength() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetRequestStatusCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetResolveRetry() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetResolveTimeOut() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetSendTimeOut() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpSetSocketCreationCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsFreeCaList() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsGetCaList() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsGetSslError() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsLoadCert() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsSetMinSslVersion() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsSetSslCallback() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsSetSslVersion() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpsUnloadCert() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpTerm() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpTryGetNonblock() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpTrySetNonblock() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUnsetEpoll() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriBuild() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriCopy() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriEscape() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriMerge() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriParse() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriSweepPath() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpUriUnescape() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceHttpWaitRequest() { + LOG_ERROR(Lib_Http, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceHttp(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("hvG6GfBMXg8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortRequest); + LIB_FUNCTION("JKl06ZIAl6A", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortRequestForce); + LIB_FUNCTION("sWQiqKvYTVA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAbortWaitRequest); + LIB_FUNCTION("mNan6QSnpeY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddCookie); + LIB_FUNCTION("JM58a21mtrQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddQuery); + LIB_FUNCTION("EY28T2bkN7k", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddRequestHeader); + LIB_FUNCTION("lGAjftanhFs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAddRequestHeaderRaw); + LIB_FUNCTION("Y1DCjN-s2BA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheExport); + LIB_FUNCTION("zzB0StvRab4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheFlush); + LIB_FUNCTION("wF0KcxK20BE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpAuthCacheImport); + LIB_FUNCTION("A7n9nNg7NBg", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpCacheRedirectedConnectionEnabled); + LIB_FUNCTION("nOkViL17ZOo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieExport); + LIB_FUNCTION("seCvUt91WHY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieFlush); + LIB_FUNCTION("pFnXDxo3aog", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCookieImport); + LIB_FUNCTION("Kiwv9r4IZCc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateConnection); + LIB_FUNCTION("qgxDBjorUxs", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpCreateConnectionWithURL); + LIB_FUNCTION("6381dWF+xsQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateEpoll); + LIB_FUNCTION("tsGVru3hCe8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequest); + LIB_FUNCTION("rGNm+FjIXKk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequest2); + LIB_FUNCTION("Aeu5wVKkF9w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequestWithURL); + LIB_FUNCTION("Cnp77podkCU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateRequestWithURL2); + LIB_FUNCTION("0gYjPTR-6cY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpCreateTemplate); + LIB_FUNCTION("Lffcxao-QMM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgEnableProfile); + LIB_FUNCTION("6gyx-I0Oob4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgGetConnectionStat); + LIB_FUNCTION("fzzBpJjm9Kw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgGetRequestStat); + LIB_FUNCTION("VmqSnjZ5mE4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgSetPrintf); + LIB_FUNCTION("KJtUHtp6y0U", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowConnectionStat); + LIB_FUNCTION("oEuPssSYskA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowMemoryPoolStat); + LIB_FUNCTION("L2gM3qptqHs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowRequestStat); + LIB_FUNCTION("pxBsD-X9eH0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDbgShowStat); + LIB_FUNCTION("P6A3ytpsiYc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteConnection); + LIB_FUNCTION("qe7oZ+v4PWA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteRequest); + LIB_FUNCTION("4I8vEpuEhZ8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDeleteTemplate); + LIB_FUNCTION("wYhXVfS2Et4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpDestroyEpoll); + LIB_FUNCTION("1rpZqxdMRwQ", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpGetAcceptEncodingGZIPEnabled); + LIB_FUNCTION("aCYPMSUIaP8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAllResponseHeaders); + LIB_FUNCTION("9m8EcOGzcIQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAuthEnabled); + LIB_FUNCTION("mmLexUbtnfY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetAutoRedirect); + LIB_FUNCTION("L-DwVoHXLtU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetConnectionStat); + LIB_FUNCTION("+G+UsJpeXPc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookie); + LIB_FUNCTION("iSZjWw1TGiA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookieEnabled); + LIB_FUNCTION("xkymWiGdMiI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetCookieStats); + LIB_FUNCTION("7j9VcwnrZo4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetEpoll); + LIB_FUNCTION("IQOP6McWJcY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetEpollId); + LIB_FUNCTION("0onIrKx9NIE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetLastErrno); + LIB_FUNCTION("16sMmVuOvgU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetMemoryPoolStats); + LIB_FUNCTION("Wq4RNB3snSQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetNonblock); + LIB_FUNCTION("hkcfqAl+82w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetRegisteredCtxIds); + LIB_FUNCTION("yuO2H2Uvnos", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpGetResponseContentLength); + LIB_FUNCTION("0a2TBNfE3BU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpGetStatusCode); + LIB_FUNCTION("A9cVMUtEp4Y", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpInit); + LIB_FUNCTION("hPTXo3bICzI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpParseResponseHeader); + LIB_FUNCTION("Qq8SfuJJJqE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpParseStatusLine); + LIB_FUNCTION("P5pdoykPYTk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpReadData); + LIB_FUNCTION("u05NnI+P+KY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRedirectCacheFlush); + LIB_FUNCTION("zNGh-zoQTD0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRemoveRequestHeader); + LIB_FUNCTION("4fgkfVeVsGU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpRequestGetAllHeaders); + LIB_FUNCTION("mSQCxzWTwVI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsDisableOption); + LIB_FUNCTION("zJYi5br6ZiQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsDisableOptionPrivate); + LIB_FUNCTION("f42K37mm5RM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsEnableOption); + LIB_FUNCTION("I4+4hKttt1w", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsEnableOptionPrivate); + LIB_FUNCTION("1e2BNwI-XzE", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSendRequest); + LIB_FUNCTION("HRX1iyDoKR8", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetAcceptEncodingGZIPEnabled); + LIB_FUNCTION("qFg2SuyTJJY", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAuthEnabled); + LIB_FUNCTION("jf4TB2nUO40", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAuthInfoCallback); + LIB_FUNCTION("T-mGo9f3Pu4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetAutoRedirect); + LIB_FUNCTION("PDxS48xGQLs", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetChunkedTransferEnabled); + LIB_FUNCTION("0S9tTH0uqTU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetConnectTimeOut); + LIB_FUNCTION("XNUoD2B9a6A", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieEnabled); + LIB_FUNCTION("pM--+kIeW-8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieMaxNum); + LIB_FUNCTION("Kp6juCJUJGQ", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetCookieMaxNumPerDomain); + LIB_FUNCTION("7Y4364GBras", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieMaxSize); + LIB_FUNCTION("Kh6bS2HQKbo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieRecvCallback); + LIB_FUNCTION("GnVDzYfy-KI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieSendCallback); + LIB_FUNCTION("pHc3bxUzivU", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetCookieTotalMaxSize); + LIB_FUNCTION("8kzIXsRy1bY", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetDefaultAcceptEncodingGZIPEnabled); + LIB_FUNCTION("22buO-UufJY", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetDelayBuildRequestEnabled); + LIB_FUNCTION("-xm7kZQNpHI", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetEpoll); + LIB_FUNCTION("LG1YW1Uhkgo", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetEpollId); + LIB_FUNCTION("pk0AuomQM1o", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetHttp09Enabled); + LIB_FUNCTION("i9mhafzkEi8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetInflateGZIPEnabled); + LIB_FUNCTION("s2-NPIvz+iA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetNonblock); + LIB_FUNCTION("gZ9TpeFQ7Gk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetPolicyOption); + LIB_FUNCTION("2NeZnMEP3-0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetPriorityOption); + LIB_FUNCTION("i+quCZCL+D8", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetProxy); + LIB_FUNCTION("mMcB2XIDoV4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRecvBlockSize); + LIB_FUNCTION("yigr4V0-HTM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRecvTimeOut); + LIB_FUNCTION("h9wmFZX4i-4", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetRedirectCallback); + LIB_FUNCTION("PTiFIUxCpJc", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetRequestContentLength); + LIB_FUNCTION("vO4B-42ef-k", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetRequestStatusCallback); + LIB_FUNCTION("K1d1LqZRQHQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetResolveRetry); + LIB_FUNCTION("Tc-hAYDKtQc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetResolveTimeOut); + LIB_FUNCTION("a4VsZ4oqn68", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetResponseHeaderMaxSize); + LIB_FUNCTION("xegFfZKBVlw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpSetSendTimeOut); + LIB_FUNCTION("POJ0azHZX3w", "libSceHttp", 1, "libSceHttp", 1, 1, + sceHttpSetSocketCreationCallback); + LIB_FUNCTION("7WcNoAI9Zcw", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsFreeCaList); + LIB_FUNCTION("gcUjwU3fa0M", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsGetCaList); + LIB_FUNCTION("JBN6N-EY+3M", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsGetSslError); + LIB_FUNCTION("DK+GoXCNT04", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsLoadCert); + LIB_FUNCTION("jUjp+yqMNdQ", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetMinSslVersion); + LIB_FUNCTION("htyBOoWeS58", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetSslCallback); + LIB_FUNCTION("U5ExQGyyx9s", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsSetSslVersion); + LIB_FUNCTION("zXqcE0fizz0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpsUnloadCert); + LIB_FUNCTION("Ik-KpLTlf7Q", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTerm); + LIB_FUNCTION("V-noPEjSB8c", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTryGetNonblock); + LIB_FUNCTION("fmOs6MzCRqk", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpTrySetNonblock); + LIB_FUNCTION("59tL1AQBb8U", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUnsetEpoll); + LIB_FUNCTION("5LZA+KPISVA", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriBuild); + LIB_FUNCTION("CR-l-yI-o7o", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriCopy); + LIB_FUNCTION("YuOW3dDAKYc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriEscape); + LIB_FUNCTION("3lgQ5Qk42ok", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriMerge); + LIB_FUNCTION("IWalAn-guFs", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriParse); + LIB_FUNCTION("mUU363n4yc0", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriSweepPath); + LIB_FUNCTION("thTS+57zoLM", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpUriUnescape); + LIB_FUNCTION("qISjDHrxONc", "libSceHttp", 1, "libSceHttp", 1, 1, sceHttpWaitRequest); +}; + +} // namespace Libraries::Http \ No newline at end of file diff --git a/src/core/libraries/libscehttp.h b/src/core/libraries/libscehttp.h new file mode 100644 index 00000000..f666b716 --- /dev/null +++ b/src/core/libraries/libscehttp.h @@ -0,0 +1,127 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::Http { + +int PS4_SYSV_ABI sceHttpAbortRequest(); +int PS4_SYSV_ABI sceHttpAbortRequestForce(); +int PS4_SYSV_ABI sceHttpAbortWaitRequest(); +int PS4_SYSV_ABI sceHttpAddCookie(); +int PS4_SYSV_ABI sceHttpAddQuery(); +int PS4_SYSV_ABI sceHttpAddRequestHeader(); +int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw(); +int PS4_SYSV_ABI sceHttpAuthCacheExport(); +int PS4_SYSV_ABI sceHttpAuthCacheFlush(); +int PS4_SYSV_ABI sceHttpAuthCacheImport(); +int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled(); +int PS4_SYSV_ABI sceHttpCookieExport(); +int PS4_SYSV_ABI sceHttpCookieFlush(); +int PS4_SYSV_ABI sceHttpCookieImport(); +int PS4_SYSV_ABI sceHttpCreateConnection(); +int PS4_SYSV_ABI sceHttpCreateConnectionWithURL(); +int PS4_SYSV_ABI sceHttpCreateEpoll(); +int PS4_SYSV_ABI sceHttpCreateRequest(); +int PS4_SYSV_ABI sceHttpCreateRequest2(); +int PS4_SYSV_ABI sceHttpCreateRequestWithURL(); +int PS4_SYSV_ABI sceHttpCreateRequestWithURL2(); +int PS4_SYSV_ABI sceHttpCreateTemplate(); +int PS4_SYSV_ABI sceHttpDbgEnableProfile(); +int PS4_SYSV_ABI sceHttpDbgGetConnectionStat(); +int PS4_SYSV_ABI sceHttpDbgGetRequestStat(); +int PS4_SYSV_ABI sceHttpDbgSetPrintf(); +int PS4_SYSV_ABI sceHttpDbgShowConnectionStat(); +int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat(); +int PS4_SYSV_ABI sceHttpDbgShowRequestStat(); +int PS4_SYSV_ABI sceHttpDbgShowStat(); +int PS4_SYSV_ABI sceHttpDeleteConnection(); +int PS4_SYSV_ABI sceHttpDeleteRequest(); +int PS4_SYSV_ABI sceHttpDeleteTemplate(); +int PS4_SYSV_ABI sceHttpDestroyEpoll(); +int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled(); +int PS4_SYSV_ABI sceHttpGetAllResponseHeaders(); +int PS4_SYSV_ABI sceHttpGetAuthEnabled(); +int PS4_SYSV_ABI sceHttpGetAutoRedirect(); +int PS4_SYSV_ABI sceHttpGetConnectionStat(); +int PS4_SYSV_ABI sceHttpGetCookie(); +int PS4_SYSV_ABI sceHttpGetCookieEnabled(); +int PS4_SYSV_ABI sceHttpGetCookieStats(); +int PS4_SYSV_ABI sceHttpGetEpoll(); +int PS4_SYSV_ABI sceHttpGetEpollId(); +int PS4_SYSV_ABI sceHttpGetLastErrno(); +int PS4_SYSV_ABI sceHttpGetMemoryPoolStats(); +int PS4_SYSV_ABI sceHttpGetNonblock(); +int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds(); +int PS4_SYSV_ABI sceHttpGetResponseContentLength(); +int PS4_SYSV_ABI sceHttpGetStatusCode(); +int PS4_SYSV_ABI sceHttpInit(); +int PS4_SYSV_ABI sceHttpParseResponseHeader(); +int PS4_SYSV_ABI sceHttpParseStatusLine(); +int PS4_SYSV_ABI sceHttpReadData(); +int PS4_SYSV_ABI sceHttpRedirectCacheFlush(); +int PS4_SYSV_ABI sceHttpRemoveRequestHeader(); +int PS4_SYSV_ABI sceHttpRequestGetAllHeaders(); +int PS4_SYSV_ABI sceHttpsDisableOption(); +int PS4_SYSV_ABI sceHttpsDisableOptionPrivate(); +int PS4_SYSV_ABI sceHttpsEnableOption(); +int PS4_SYSV_ABI sceHttpsEnableOptionPrivate(); +int PS4_SYSV_ABI sceHttpSendRequest(); +int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled(); +int PS4_SYSV_ABI sceHttpSetAuthEnabled(); +int PS4_SYSV_ABI sceHttpSetAuthInfoCallback(); +int PS4_SYSV_ABI sceHttpSetAutoRedirect(); +int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled(); +int PS4_SYSV_ABI sceHttpSetConnectTimeOut(); +int PS4_SYSV_ABI sceHttpSetCookieEnabled(); +int PS4_SYSV_ABI sceHttpSetCookieMaxNum(); +int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain(); +int PS4_SYSV_ABI sceHttpSetCookieMaxSize(); +int PS4_SYSV_ABI sceHttpSetCookieRecvCallback(); +int PS4_SYSV_ABI sceHttpSetCookieSendCallback(); +int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize(); +int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled(); +int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled(); +int PS4_SYSV_ABI sceHttpSetEpoll(); +int PS4_SYSV_ABI sceHttpSetEpollId(); +int PS4_SYSV_ABI sceHttpSetHttp09Enabled(); +int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled(); +int PS4_SYSV_ABI sceHttpSetNonblock(); +int PS4_SYSV_ABI sceHttpSetPolicyOption(); +int PS4_SYSV_ABI sceHttpSetPriorityOption(); +int PS4_SYSV_ABI sceHttpSetProxy(); +int PS4_SYSV_ABI sceHttpSetRecvBlockSize(); +int PS4_SYSV_ABI sceHttpSetRecvTimeOut(); +int PS4_SYSV_ABI sceHttpSetRedirectCallback(); +int PS4_SYSV_ABI sceHttpSetRequestContentLength(); +int PS4_SYSV_ABI sceHttpSetRequestStatusCallback(); +int PS4_SYSV_ABI sceHttpSetResolveRetry(); +int PS4_SYSV_ABI sceHttpSetResolveTimeOut(); +int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize(); +int PS4_SYSV_ABI sceHttpSetSendTimeOut(); +int PS4_SYSV_ABI sceHttpSetSocketCreationCallback(); +int PS4_SYSV_ABI sceHttpsFreeCaList(); +int PS4_SYSV_ABI sceHttpsGetCaList(); +int PS4_SYSV_ABI sceHttpsGetSslError(); +int PS4_SYSV_ABI sceHttpsLoadCert(); +int PS4_SYSV_ABI sceHttpsSetMinSslVersion(); +int PS4_SYSV_ABI sceHttpsSetSslCallback(); +int PS4_SYSV_ABI sceHttpsSetSslVersion(); +int PS4_SYSV_ABI sceHttpsUnloadCert(); +int PS4_SYSV_ABI sceHttpTerm(); +int PS4_SYSV_ABI sceHttpTryGetNonblock(); +int PS4_SYSV_ABI sceHttpTrySetNonblock(); +int PS4_SYSV_ABI sceHttpUnsetEpoll(); +int PS4_SYSV_ABI sceHttpUriBuild(); +int PS4_SYSV_ABI sceHttpUriCopy(); +int PS4_SYSV_ABI sceHttpUriEscape(); +int PS4_SYSV_ABI sceHttpUriMerge(); +int PS4_SYSV_ABI sceHttpUriParse(); +int PS4_SYSV_ABI sceHttpUriSweepPath(); +int PS4_SYSV_ABI sceHttpUriUnescape(); +int PS4_SYSV_ABI sceHttpWaitRequest(); + +void RegisterlibSceHttp(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Http \ No newline at end of file diff --git a/src/core/libraries/libscenet.cpp b/src/core/libraries/libscenet.cpp new file mode 100644 index 00000000..da5c8550 --- /dev/null +++ b/src/core/libraries/libscenet.cpp @@ -0,0 +1,1356 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libscenet.h" + +namespace Libraries::Net { + +int PS4_SYSV_ABI in6addr_any() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI in6addr_loopback() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_dummy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_in6addr_any() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_in6addr_linklocal_allnodes() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_in6addr_linklocal_allrouters() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_in6addr_loopback() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sce_net_in6addr_nodelocal_allnodes() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetAccept() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetAddrConfig6GetInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetAddrConfig6Start() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetAddrConfig6Stop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetAllocateAllRouteInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlGetDataTraffic() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlGetDefaultParam() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlGetIfParam() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlGetPolicy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlSetDefaultParam() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlSetIfParam() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBandwidthControlSetPolicy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBind() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetClearDnsCache() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddArp() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddArpWithInterface() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddIfaddr() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddMRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigAddRouteWithInterface() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigCleanUpAllInterfaces() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelArp() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelArpWithInterface() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelDefaultRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelDefaultRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelIfaddr() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelIfaddr6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelMRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDelRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigDownInterface() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigEtherGetLinkMode() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigEtherPostPlugInOutEvent() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigEtherSetLinkMode() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigFlushRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigGetDefaultRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigGetDefaultRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigGetIfaddr() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigGetIfaddr6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigRoutingShowRoutingConfig() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigRoutingShowtCtlVar() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigRoutingStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigRoutingStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetDefaultRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetDefaultRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetDefaultScope() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfaddr() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfaddr6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfaddr6WithFlags() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfFlags() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfLinkLocalAddr6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigSetIfmtu() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigUnsetIfFlags() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigUpInterface() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigUpInterfaceWithFlags() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocClearWakeOnWlan() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocGetWakeOnWlanInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocJoin() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocLeave() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuClearWakeOnWlan() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuGetWakeOnWlanInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuSetWakeOnWlan() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocScanJoin() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocSetExtInfoElement() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanAdhocSetWakeOnWlan() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanApStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanApStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanQuery() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanDiagGetDeviceInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanDiagSetAntenna() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanDiagSetTxFixedRate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanGetDeviceConfig() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanInfraGetRssiInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanInfraLeave() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanInfraScanJoin() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanScan() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConfigWlanSetDeviceConfig() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetConnect() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetControl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpdStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpdStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpGetAutoipInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpGetInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpGetInfoEx() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDhcpStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDumpAbort() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDumpCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDumpDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDumpRead() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDuplicateIpStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetDuplicateIpStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEpollAbort() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEpollControl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEpollCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEpollDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEpollWait() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetErrnoLoc() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEtherNtostr() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEtherStrton() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEventCallbackCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEventCallbackDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEventCallbackGetError() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEventCallbackWaitCB() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetFreeAllRouteInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetArpInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetDns6Info() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetDnsInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetIfList() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetIfListOnce() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetIfName() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetIfnameNumList() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetMacAddress() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetMemoryPoolStats() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetNameToIndex() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetpeername() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetRandom() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetRouteInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetSockInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetSockInfo6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetsockname() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetsockopt() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetStatisticsInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetStatisticsInfoInternal() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetGetSystemTime() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetHtonl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetHtonll() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetHtons() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInetNtop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInetNtopWithScopeId() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInetPton() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInetPtonEx() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInetPtonWithScopeId() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInfoDumpStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInfoDumpStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInit() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetInitParam() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetIoctl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetListen() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetMemoryAllocate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetMemoryFree() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetNtohl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetNtohll() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetNtohs() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetPoolCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetPoolDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetPppoeStart() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetPppoeStop() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetRecv() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetRecvfrom() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetRecvmsg() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverAbort() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverConnect() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverConnectAbort() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverConnectCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverConnectDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverGetError() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartAton() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartAton6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartNtoa() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartNtoa6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecords() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecordsEx() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSend() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSendmsg() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSendto() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSetDns6Info() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSetDns6InfoToKernel() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSetDnsInfo() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSetDnsInfoToKernel() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSetsockopt() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowIfconfig() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowIfconfigForBuffer() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowIfconfigWithMemory() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowNetstat() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowNetstatEx() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowNetstatExForBuffer() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowNetstatForBuffer() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowNetstatWithMemory() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowPolicy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowPolicyWithMemory() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRoute() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRoute6() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRoute6ForBuffer() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRoute6WithMemory() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRouteForBuffer() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShowRouteWithMemory() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetShutdown() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSocket() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSocketAbort() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSocketClose() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSyncCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSyncDestroy() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSyncGet() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSyncSignal() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSyncWait() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetSysctl() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetTerm() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetThreadCreate() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetThreadExit() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetThreadJoin() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetUsleep() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_0E707A589F751C68() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEmulationGet() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetEmulationSet() { + LOG_ERROR(Lib_Net, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceNet(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("ZRAJo-A-ukc", "libSceNet", 1, "libSceNet", 1, 1, in6addr_any); + LIB_FUNCTION("XCuA-GqjA-k", "libSceNet", 1, "libSceNet", 1, 1, in6addr_loopback); + LIB_FUNCTION("VZgoeBxPXUQ", "libSceNet", 1, "libSceNet", 1, 1, sce_net_dummy); + LIB_FUNCTION("GAtITrgxKDE", "libSceNet", 1, "libSceNet", 1, 1, sce_net_in6addr_any); + LIB_FUNCTION("84MgU4MMTLQ", "libSceNet", 1, "libSceNet", 1, 1, + sce_net_in6addr_linklocal_allnodes); + LIB_FUNCTION("2uSWyOKYc1M", "libSceNet", 1, "libSceNet", 1, 1, + sce_net_in6addr_linklocal_allrouters); + LIB_FUNCTION("P3AeWBvPrkg", "libSceNet", 1, "libSceNet", 1, 1, sce_net_in6addr_loopback); + LIB_FUNCTION("PgNI+j4zxzM", "libSceNet", 1, "libSceNet", 1, 1, + sce_net_in6addr_nodelocal_allnodes); + LIB_FUNCTION("PIWqhn9oSxc", "libSceNet", 1, "libSceNet", 1, 1, sceNetAccept); + LIB_FUNCTION("BTUvkWzrP68", "libSceNet", 1, "libSceNet", 1, 1, sceNetAddrConfig6GetInfo); + LIB_FUNCTION("3qG7UJy2Fq8", "libSceNet", 1, "libSceNet", 1, 1, sceNetAddrConfig6Start); + LIB_FUNCTION("P+0ePpDfUAQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetAddrConfig6Stop); + LIB_FUNCTION("PcdLABhYga4", "libSceNet", 1, "libSceNet", 1, 1, sceNetAllocateAllRouteInfo); + LIB_FUNCTION("xHq87H78dho", "libSceNet", 1, "libSceNet", 1, 1, + sceNetBandwidthControlGetDataTraffic); + LIB_FUNCTION("c8IRpl4L74I", "libSceNet", 1, "libSceNet", 1, 1, + sceNetBandwidthControlGetDefaultParam); + LIB_FUNCTION("b9Ft65tqvLk", "libSceNet", 1, "libSceNet", 1, 1, + sceNetBandwidthControlGetIfParam); + LIB_FUNCTION("PDkapOwggRw", "libSceNet", 1, "libSceNet", 1, 1, sceNetBandwidthControlGetPolicy); + LIB_FUNCTION("P4zZXE7bpsA", "libSceNet", 1, "libSceNet", 1, 1, + sceNetBandwidthControlSetDefaultParam); + LIB_FUNCTION("g4DKkzV2qC4", "libSceNet", 1, "libSceNet", 1, 1, + sceNetBandwidthControlSetIfParam); + LIB_FUNCTION("7Z1hhsEmkQU", "libSceNet", 1, "libSceNet", 1, 1, sceNetBandwidthControlSetPolicy); + LIB_FUNCTION("bErx49PgxyY", "libSceNet", 1, "libSceNet", 1, 1, sceNetBind); + LIB_FUNCTION("eyLyLJrdEOU", "libSceNet", 1, "libSceNet", 1, 1, sceNetClearDnsCache); + LIB_FUNCTION("Ea2NaVMQNO8", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddArp); + LIB_FUNCTION("0g0qIuPN3ZQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddArpWithInterface); + LIB_FUNCTION("ge7g15Sqhks", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddIfaddr); + LIB_FUNCTION("FDHr4Iz7dQU", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddMRoute); + LIB_FUNCTION("Cyjl1yzi1qY", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddRoute); + LIB_FUNCTION("Bu+L5r1lKRg", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigAddRoute6); + LIB_FUNCTION("wIGold7Lro0", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigAddRouteWithInterface); + LIB_FUNCTION("MzA1YrRE6rA", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigCleanUpAllInterfaces); + LIB_FUNCTION("HJt+4x-CnY0", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelArp); + LIB_FUNCTION("xTcttXJ3Utg", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelArpWithInterface); + LIB_FUNCTION("RuVwHEW6dM4", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelDefaultRoute); + LIB_FUNCTION("UMlVCy7RX1s", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelDefaultRoute6); + LIB_FUNCTION("0239JNsI6PE", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelIfaddr); + LIB_FUNCTION("hvCXMwd45oc", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelIfaddr6); + LIB_FUNCTION("5Yl1uuh5i-A", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelMRoute); + LIB_FUNCTION("QO7+2E3cD-U", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelRoute); + LIB_FUNCTION("4wDGvfhmkmk", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDelRoute6); + LIB_FUNCTION("3WzWV86AJ3w", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigDownInterface); + LIB_FUNCTION("mOUkgTaSkJU", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigEtherGetLinkMode); + LIB_FUNCTION("pF3Vy1iZ5bs", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigEtherPostPlugInOutEvent); + LIB_FUNCTION("QltDK6wWqF0", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigEtherSetLinkMode); + LIB_FUNCTION("18KNgSvYx+Y", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigFlushRoute); + LIB_FUNCTION("lFJb+BlPK1c", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigGetDefaultRoute); + LIB_FUNCTION("mCLdiNIKtW0", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigGetDefaultRoute6); + LIB_FUNCTION("ejwa0hWWhDs", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigGetIfaddr); + LIB_FUNCTION("FU6NK4RHQVE", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigGetIfaddr6); + LIB_FUNCTION("vbZLomImmEE", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigRoutingShowRoutingConfig); + LIB_FUNCTION("a6sS6iSE0IA", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigRoutingShowtCtlVar); + LIB_FUNCTION("eszLdtIMfQE", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigRoutingStart); + LIB_FUNCTION("toi8xxcSfJ0", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigRoutingStop); + LIB_FUNCTION("EAl7xvi7nXg", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetDefaultRoute); + LIB_FUNCTION("4zLOHbt3UFk", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetDefaultRoute6); + LIB_FUNCTION("yaVAdLDxUj0", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetDefaultScope); + LIB_FUNCTION("8Kh+1eidI3c", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfaddr); + LIB_FUNCTION("QJbV3vfBQ8Q", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfaddr6); + LIB_FUNCTION("POrSEl8zySw", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfaddr6WithFlags); + LIB_FUNCTION("0sesmAYH3Lk", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfFlags); + LIB_FUNCTION("uNTluLfYgS8", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfLinkLocalAddr6); + LIB_FUNCTION("s31rYkpIMMQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigSetIfmtu); + LIB_FUNCTION("tvdzQkm+UaY", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigUnsetIfFlags); + LIB_FUNCTION("oGEBX0eXGFs", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigUpInterface); + LIB_FUNCTION("6HNbayHPL7c", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigUpInterfaceWithFlags); + LIB_FUNCTION("6A6EweB3Dto", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocClearWakeOnWlan); + LIB_FUNCTION("ZLdJyQJUMkM", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanAdhocCreate); + LIB_FUNCTION("Yr3UeApLWTY", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocGetWakeOnWlanInfo); + LIB_FUNCTION("Xma8yHmV+TQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanAdhocJoin); + LIB_FUNCTION("K4o48GTNbSc", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanAdhocLeave); + LIB_FUNCTION("ZvKgNrrLCCQ", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocPspEmuClearWakeOnWlan); + LIB_FUNCTION("1j4DZ5dXbeQ", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocPspEmuGetWakeOnWlanInfo); + LIB_FUNCTION("C-+JPjaEhdA", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocPspEmuSetWakeOnWlan); + LIB_FUNCTION("7xYdUWg1WdY", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanAdhocScanJoin); + LIB_FUNCTION("Q7ee2Uav5f8", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocSetExtInfoElement); + LIB_FUNCTION("xaOTiuxIQNY", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanAdhocSetWakeOnWlan); + LIB_FUNCTION("QlRJWya+dtE", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanApStart); + LIB_FUNCTION("6uYcvVjH7Ms", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanApStop); + LIB_FUNCTION("MDbg-oAj8Aw", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanBackgroundScanQuery); + LIB_FUNCTION("cMA8f6jI6s0", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanBackgroundScanStart); + LIB_FUNCTION("3T5aIe-7L84", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanBackgroundScanStop); + LIB_FUNCTION("+3KMyS93TOs", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanDiagGetDeviceInfo); + LIB_FUNCTION("9oiOWQ5FMws", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanDiagSetAntenna); + LIB_FUNCTION("fHr45B97n0U", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanDiagSetTxFixedRate); + LIB_FUNCTION("PNDDxnqqtk4", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanGetDeviceConfig); + LIB_FUNCTION("Pkx0lwWVzmQ", "libSceNet", 1, "libSceNet", 1, 1, + sceNetConfigWlanInfraGetRssiInfo); + LIB_FUNCTION("IkBCxG+o4Nk", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanInfraLeave); + LIB_FUNCTION("273-I-zD8+8", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanInfraScanJoin); + LIB_FUNCTION("-Mi5hNiWC4c", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanScan); + LIB_FUNCTION("U1q6DrPbY6k", "libSceNet", 1, "libSceNet", 1, 1, sceNetConfigWlanSetDeviceConfig); + LIB_FUNCTION("OXXX4mUk3uk", "libSceNet", 1, "libSceNet", 1, 1, sceNetConnect); + LIB_FUNCTION("lDTIbqNs0ps", "libSceNet", 1, "libSceNet", 1, 1, sceNetControl); + LIB_FUNCTION("Q6T-zIblNqk", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpdStart); + LIB_FUNCTION("xwWm8jzrpeM", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpdStop); + LIB_FUNCTION("KhQxhlEslo0", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpGetAutoipInfo); + LIB_FUNCTION("ix4LWXd12F0", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpGetInfo); + LIB_FUNCTION("DrZuCQDnm3w", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpGetInfoEx); + LIB_FUNCTION("Wzv6dngR-DQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpStart); + LIB_FUNCTION("6AN7OlSMWk0", "libSceNet", 1, "libSceNet", 1, 1, sceNetDhcpStop); + LIB_FUNCTION("+ezgWao0wo8", "libSceNet", 1, "libSceNet", 1, 1, sceNetDumpAbort); + LIB_FUNCTION("bghgkeLKq1Q", "libSceNet", 1, "libSceNet", 1, 1, sceNetDumpCreate); + LIB_FUNCTION("xZ54Il-u1vs", "libSceNet", 1, "libSceNet", 1, 1, sceNetDumpDestroy); + LIB_FUNCTION("YWTpt45PxbI", "libSceNet", 1, "libSceNet", 1, 1, sceNetDumpRead); + LIB_FUNCTION("TwjkDIPdZ1Q", "libSceNet", 1, "libSceNet", 1, 1, sceNetDuplicateIpStart); + LIB_FUNCTION("QCbvCx9HL30", "libSceNet", 1, "libSceNet", 1, 1, sceNetDuplicateIpStop); + LIB_FUNCTION("w21YgGGNtBk", "libSceNet", 1, "libSceNet", 1, 1, sceNetEpollAbort); + LIB_FUNCTION("ZVw46bsasAk", "libSceNet", 1, "libSceNet", 1, 1, sceNetEpollControl); + LIB_FUNCTION("SF47kB2MNTo", "libSceNet", 1, "libSceNet", 1, 1, sceNetEpollCreate); + LIB_FUNCTION("Inp1lfL+Jdw", "libSceNet", 1, "libSceNet", 1, 1, sceNetEpollDestroy); + LIB_FUNCTION("drjIbDbA7UQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetEpollWait); + LIB_FUNCTION("HQOwnfMGipQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetErrnoLoc); + LIB_FUNCTION("v6M4txecCuo", "libSceNet", 1, "libSceNet", 1, 1, sceNetEtherNtostr); + LIB_FUNCTION("b-bFZvNV59I", "libSceNet", 1, "libSceNet", 1, 1, sceNetEtherStrton); + LIB_FUNCTION("cWGGXoeZUzA", "libSceNet", 1, "libSceNet", 1, 1, sceNetEventCallbackCreate); + LIB_FUNCTION("jzP0MoZpYnI", "libSceNet", 1, "libSceNet", 1, 1, sceNetEventCallbackDestroy); + LIB_FUNCTION("tB3BB8AsrjU", "libSceNet", 1, "libSceNet", 1, 1, sceNetEventCallbackGetError); + LIB_FUNCTION("5isaotjMWlA", "libSceNet", 1, "libSceNet", 1, 1, sceNetEventCallbackWaitCB); + LIB_FUNCTION("2ee14ktE1lw", "libSceNet", 1, "libSceNet", 1, 1, sceNetFreeAllRouteInfo); + LIB_FUNCTION("q8j9OSdnN1Y", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetArpInfo); + LIB_FUNCTION("wmoIm94hqik", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetDns6Info); + LIB_FUNCTION("nCL0NyZsd5A", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetDnsInfo); + LIB_FUNCTION("HoV-GJyx7YY", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetIfList); + LIB_FUNCTION("ahiOMqoYYMc", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetIfListOnce); + LIB_FUNCTION("0MT2l3uIX7c", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetIfName); + LIB_FUNCTION("5lrSEHdqyos", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetIfnameNumList); + LIB_FUNCTION("6Oc0bLsIYe0", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetMacAddress); + LIB_FUNCTION("rMyh97BU5pY", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetMemoryPoolStats); + LIB_FUNCTION("+S-2-jlpaBo", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetNameToIndex); + LIB_FUNCTION("TCkRD0DWNLg", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetpeername); + LIB_FUNCTION("G3O2j9f5z00", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetRandom); + LIB_FUNCTION("6Nx1hIQL9h8", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetRouteInfo); + LIB_FUNCTION("hLuXdjHnhiI", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetSockInfo); + LIB_FUNCTION("Cidi9Y65mP8", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetSockInfo6); + LIB_FUNCTION("hoOAofhhRvE", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetsockname); + LIB_FUNCTION("xphrZusl78E", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetsockopt); + LIB_FUNCTION("GA5ZDaLtUBE", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetStatisticsInfo); + LIB_FUNCTION("9mIcUExH34w", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetStatisticsInfoInternal); + LIB_FUNCTION("p2vxsE2U3RQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetGetSystemTime); + LIB_FUNCTION("9T2pDF2Ryqg", "libSceNet", 1, "libSceNet", 1, 1, sceNetHtonl); + LIB_FUNCTION("3CHi1K1wsCQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetHtonll); + LIB_FUNCTION("iWQWrwiSt8A", "libSceNet", 1, "libSceNet", 1, 1, sceNetHtons); + LIB_FUNCTION("9vA2aW+CHuA", "libSceNet", 1, "libSceNet", 1, 1, sceNetInetNtop); + LIB_FUNCTION("Eh+Vqkrrc00", "libSceNet", 1, "libSceNet", 1, 1, sceNetInetNtopWithScopeId); + LIB_FUNCTION("8Kcp5d-q1Uo", "libSceNet", 1, "libSceNet", 1, 1, sceNetInetPton); + LIB_FUNCTION("Xn2TA2QhxHc", "libSceNet", 1, "libSceNet", 1, 1, sceNetInetPtonEx); + LIB_FUNCTION("b+LixqREH6A", "libSceNet", 1, "libSceNet", 1, 1, sceNetInetPtonWithScopeId); + LIB_FUNCTION("cYW1ISGlOmo", "libSceNet", 1, "libSceNet", 1, 1, sceNetInfoDumpStart); + LIB_FUNCTION("XfV-XBCuhDo", "libSceNet", 1, "libSceNet", 1, 1, sceNetInfoDumpStop); + LIB_FUNCTION("Nlev7Lg8k3A", "libSceNet", 1, "libSceNet", 1, 1, sceNetInit); + LIB_FUNCTION("6MojQ8uFHEI", "libSceNet", 1, "libSceNet", 1, 1, sceNetInitParam); + LIB_FUNCTION("ghqRRVQxqKo", "libSceNet", 1, "libSceNet", 1, 1, sceNetIoctl); + LIB_FUNCTION("kOj1HiAGE54", "libSceNet", 1, "libSceNet", 1, 1, sceNetListen); + LIB_FUNCTION("HKIa-WH0AZ4", "libSceNet", 1, "libSceNet", 1, 1, sceNetMemoryAllocate); + LIB_FUNCTION("221fvqVs+sQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetMemoryFree); + LIB_FUNCTION("pQGpHYopAIY", "libSceNet", 1, "libSceNet", 1, 1, sceNetNtohl); + LIB_FUNCTION("tOrRi-v3AOM", "libSceNet", 1, "libSceNet", 1, 1, sceNetNtohll); + LIB_FUNCTION("Rbvt+5Y2iEw", "libSceNet", 1, "libSceNet", 1, 1, sceNetNtohs); + LIB_FUNCTION("dgJBaeJnGpo", "libSceNet", 1, "libSceNet", 1, 1, sceNetPoolCreate); + LIB_FUNCTION("K7RlrTkI-mw", "libSceNet", 1, "libSceNet", 1, 1, sceNetPoolDestroy); + LIB_FUNCTION("QGOqGPnk5a4", "libSceNet", 1, "libSceNet", 1, 1, sceNetPppoeStart); + LIB_FUNCTION("FIV95WE1EuE", "libSceNet", 1, "libSceNet", 1, 1, sceNetPppoeStop); + LIB_FUNCTION("9wO9XrMsNhc", "libSceNet", 1, "libSceNet", 1, 1, sceNetRecv); + LIB_FUNCTION("304ooNZxWDY", "libSceNet", 1, "libSceNet", 1, 1, sceNetRecvfrom); + LIB_FUNCTION("wvuUDv0jrMI", "libSceNet", 1, "libSceNet", 1, 1, sceNetRecvmsg); + LIB_FUNCTION("AzqoBha7js4", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverAbort); + LIB_FUNCTION("JQk8ck8vnPY", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverConnect); + LIB_FUNCTION("bonnMiDoOZg", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverConnectAbort); + LIB_FUNCTION("V5q6gvEJpw4", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverConnectCreate); + LIB_FUNCTION("QFPjG6rqeZg", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverConnectDestroy); + LIB_FUNCTION("C4UgDHHPvdw", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverCreate); + LIB_FUNCTION("kJlYH5uMAWI", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverDestroy); + LIB_FUNCTION("J5i3hiLJMPk", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverGetError); + LIB_FUNCTION("Apb4YDxKsRI", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverStartAton); + LIB_FUNCTION("zvzWA5IZMsg", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverStartAton6); + LIB_FUNCTION("Nd91WaWmG2w", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverStartNtoa); + LIB_FUNCTION("zl35YNs9jnI", "libSceNet", 1, "libSceNet", 1, 1, sceNetResolverStartNtoa6); + LIB_FUNCTION("RCCY01Xd+58", "libSceNet", 1, "libSceNet", 1, 1, + sceNetResolverStartNtoaMultipleRecords); + LIB_FUNCTION("sT4nBQKUPqM", "libSceNet", 1, "libSceNet", 1, 1, + sceNetResolverStartNtoaMultipleRecordsEx); + LIB_FUNCTION("beRjXBn-z+o", "libSceNet", 1, "libSceNet", 1, 1, sceNetSend); + LIB_FUNCTION("2eKbgcboJso", "libSceNet", 1, "libSceNet", 1, 1, sceNetSendmsg); + LIB_FUNCTION("gvD1greCu0A", "libSceNet", 1, "libSceNet", 1, 1, sceNetSendto); + LIB_FUNCTION("15Ywg-ZsSl0", "libSceNet", 1, "libSceNet", 1, 1, sceNetSetDns6Info); + LIB_FUNCTION("E3oH1qsdqCA", "libSceNet", 1, "libSceNet", 1, 1, sceNetSetDns6InfoToKernel); + LIB_FUNCTION("B-M6KjO8-+w", "libSceNet", 1, "libSceNet", 1, 1, sceNetSetDnsInfo); + LIB_FUNCTION("8s+T0bJeyLQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetSetDnsInfoToKernel); + LIB_FUNCTION("2mKX2Spso7I", "libSceNet", 1, "libSceNet", 1, 1, sceNetSetsockopt); + LIB_FUNCTION("k1V1djYpk7k", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowIfconfig); + LIB_FUNCTION("j6pkkO2zJtg", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowIfconfigForBuffer); + LIB_FUNCTION("E8dTcvQw3hg", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowIfconfigWithMemory); + LIB_FUNCTION("WxislcDAW5I", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowNetstat); + LIB_FUNCTION("rX30iWQqqzg", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowNetstatEx); + LIB_FUNCTION("vjwKTGa21f0", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowNetstatExForBuffer); + LIB_FUNCTION("mqoB+LN0pW8", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowNetstatForBuffer); + LIB_FUNCTION("H5WHYRfDkR0", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowNetstatWithMemory); + LIB_FUNCTION("tk0p0JmiBkM", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowPolicy); + LIB_FUNCTION("dbrSNEuZfXI", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowPolicyWithMemory); + LIB_FUNCTION("cEMX1VcPpQ8", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRoute); + LIB_FUNCTION("fCa7-ihdRdc", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRoute6); + LIB_FUNCTION("nTJqXsbSS1I", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRoute6ForBuffer); + LIB_FUNCTION("TCZyE2YI1uM", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRoute6WithMemory); + LIB_FUNCTION("n-IAZb7QB1Y", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRouteForBuffer); + LIB_FUNCTION("0-XSSp1kEFM", "libSceNet", 1, "libSceNet", 1, 1, sceNetShowRouteWithMemory); + LIB_FUNCTION("TSM6whtekok", "libSceNet", 1, "libSceNet", 1, 1, sceNetShutdown); + LIB_FUNCTION("Q4qBuN-c0ZM", "libSceNet", 1, "libSceNet", 1, 1, sceNetSocket); + LIB_FUNCTION("zJGf8xjFnQE", "libSceNet", 1, "libSceNet", 1, 1, sceNetSocketAbort); + LIB_FUNCTION("45ggEzakPJQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetSocketClose); + LIB_FUNCTION("6AJE2jKg-c0", "libSceNet", 1, "libSceNet", 1, 1, sceNetSyncCreate); + LIB_FUNCTION("atGfzCaXMak", "libSceNet", 1, "libSceNet", 1, 1, sceNetSyncDestroy); + LIB_FUNCTION("sAleh-BoxLA", "libSceNet", 1, "libSceNet", 1, 1, sceNetSyncGet); + LIB_FUNCTION("Z-8Jda650Vk", "libSceNet", 1, "libSceNet", 1, 1, sceNetSyncSignal); + LIB_FUNCTION("NP5gxDeYhIM", "libSceNet", 1, "libSceNet", 1, 1, sceNetSyncWait); + LIB_FUNCTION("3zRdT3O2Kxo", "libSceNet", 1, "libSceNet", 1, 1, sceNetSysctl); + LIB_FUNCTION("cTGkc6-TBlI", "libSceNet", 1, "libSceNet", 1, 1, sceNetTerm); + LIB_FUNCTION("j-Op3ibRJaQ", "libSceNet", 1, "libSceNet", 1, 1, sceNetThreadCreate); + LIB_FUNCTION("KirVfZbqniw", "libSceNet", 1, "libSceNet", 1, 1, sceNetThreadExit); + LIB_FUNCTION("pRbEzaV30qI", "libSceNet", 1, "libSceNet", 1, 1, sceNetThreadJoin); + LIB_FUNCTION("bjrzRLFali0", "libSceNet", 1, "libSceNet", 1, 1, sceNetUsleep); + LIB_FUNCTION("DnB6WJ91HGg", "libSceNet", 1, "libSceNet", 1, 1, Func_0E707A589F751C68); + LIB_FUNCTION("JK1oZe4UysY", "libSceNetDebug", 1, "libSceNet", 1, 1, sceNetEmulationGet); + LIB_FUNCTION("pfn3Fha1ydc", "libSceNetDebug", 1, "libSceNet", 1, 1, sceNetEmulationSet); +}; + +} // namespace Libraries::Net \ No newline at end of file diff --git a/src/core/libraries/libscenet.h b/src/core/libraries/libscenet.h new file mode 100644 index 00000000..b71edb49 --- /dev/null +++ b/src/core/libraries/libscenet.h @@ -0,0 +1,231 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::Net { + +int PS4_SYSV_ABI in6addr_any(); +int PS4_SYSV_ABI in6addr_loopback(); +int PS4_SYSV_ABI sce_net_dummy(); +int PS4_SYSV_ABI sce_net_in6addr_any(); +int PS4_SYSV_ABI sce_net_in6addr_linklocal_allnodes(); +int PS4_SYSV_ABI sce_net_in6addr_linklocal_allrouters(); +int PS4_SYSV_ABI sce_net_in6addr_loopback(); +int PS4_SYSV_ABI sce_net_in6addr_nodelocal_allnodes(); +int PS4_SYSV_ABI sceNetAccept(); +int PS4_SYSV_ABI sceNetAddrConfig6GetInfo(); +int PS4_SYSV_ABI sceNetAddrConfig6Start(); +int PS4_SYSV_ABI sceNetAddrConfig6Stop(); +int PS4_SYSV_ABI sceNetAllocateAllRouteInfo(); +int PS4_SYSV_ABI sceNetBandwidthControlGetDataTraffic(); +int PS4_SYSV_ABI sceNetBandwidthControlGetDefaultParam(); +int PS4_SYSV_ABI sceNetBandwidthControlGetIfParam(); +int PS4_SYSV_ABI sceNetBandwidthControlGetPolicy(); +int PS4_SYSV_ABI sceNetBandwidthControlSetDefaultParam(); +int PS4_SYSV_ABI sceNetBandwidthControlSetIfParam(); +int PS4_SYSV_ABI sceNetBandwidthControlSetPolicy(); +int PS4_SYSV_ABI sceNetBind(); +int PS4_SYSV_ABI sceNetClearDnsCache(); +int PS4_SYSV_ABI sceNetConfigAddArp(); +int PS4_SYSV_ABI sceNetConfigAddArpWithInterface(); +int PS4_SYSV_ABI sceNetConfigAddIfaddr(); +int PS4_SYSV_ABI sceNetConfigAddMRoute(); +int PS4_SYSV_ABI sceNetConfigAddRoute(); +int PS4_SYSV_ABI sceNetConfigAddRoute6(); +int PS4_SYSV_ABI sceNetConfigAddRouteWithInterface(); +int PS4_SYSV_ABI sceNetConfigCleanUpAllInterfaces(); +int PS4_SYSV_ABI sceNetConfigDelArp(); +int PS4_SYSV_ABI sceNetConfigDelArpWithInterface(); +int PS4_SYSV_ABI sceNetConfigDelDefaultRoute(); +int PS4_SYSV_ABI sceNetConfigDelDefaultRoute6(); +int PS4_SYSV_ABI sceNetConfigDelIfaddr(); +int PS4_SYSV_ABI sceNetConfigDelIfaddr6(); +int PS4_SYSV_ABI sceNetConfigDelMRoute(); +int PS4_SYSV_ABI sceNetConfigDelRoute(); +int PS4_SYSV_ABI sceNetConfigDelRoute6(); +int PS4_SYSV_ABI sceNetConfigDownInterface(); +int PS4_SYSV_ABI sceNetConfigEtherGetLinkMode(); +int PS4_SYSV_ABI sceNetConfigEtherPostPlugInOutEvent(); +int PS4_SYSV_ABI sceNetConfigEtherSetLinkMode(); +int PS4_SYSV_ABI sceNetConfigFlushRoute(); +int PS4_SYSV_ABI sceNetConfigGetDefaultRoute(); +int PS4_SYSV_ABI sceNetConfigGetDefaultRoute6(); +int PS4_SYSV_ABI sceNetConfigGetIfaddr(); +int PS4_SYSV_ABI sceNetConfigGetIfaddr6(); +int PS4_SYSV_ABI sceNetConfigRoutingShowRoutingConfig(); +int PS4_SYSV_ABI sceNetConfigRoutingShowtCtlVar(); +int PS4_SYSV_ABI sceNetConfigRoutingStart(); +int PS4_SYSV_ABI sceNetConfigRoutingStop(); +int PS4_SYSV_ABI sceNetConfigSetDefaultRoute(); +int PS4_SYSV_ABI sceNetConfigSetDefaultRoute6(); +int PS4_SYSV_ABI sceNetConfigSetDefaultScope(); +int PS4_SYSV_ABI sceNetConfigSetIfaddr(); +int PS4_SYSV_ABI sceNetConfigSetIfaddr6(); +int PS4_SYSV_ABI sceNetConfigSetIfaddr6WithFlags(); +int PS4_SYSV_ABI sceNetConfigSetIfFlags(); +int PS4_SYSV_ABI sceNetConfigSetIfLinkLocalAddr6(); +int PS4_SYSV_ABI sceNetConfigSetIfmtu(); +int PS4_SYSV_ABI sceNetConfigUnsetIfFlags(); +int PS4_SYSV_ABI sceNetConfigUpInterface(); +int PS4_SYSV_ABI sceNetConfigUpInterfaceWithFlags(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocClearWakeOnWlan(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocCreate(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocGetWakeOnWlanInfo(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocJoin(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocLeave(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuClearWakeOnWlan(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuGetWakeOnWlanInfo(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuSetWakeOnWlan(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocScanJoin(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocSetExtInfoElement(); +int PS4_SYSV_ABI sceNetConfigWlanAdhocSetWakeOnWlan(); +int PS4_SYSV_ABI sceNetConfigWlanApStart(); +int PS4_SYSV_ABI sceNetConfigWlanApStop(); +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanQuery(); +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStart(); +int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStop(); +int PS4_SYSV_ABI sceNetConfigWlanDiagGetDeviceInfo(); +int PS4_SYSV_ABI sceNetConfigWlanDiagSetAntenna(); +int PS4_SYSV_ABI sceNetConfigWlanDiagSetTxFixedRate(); +int PS4_SYSV_ABI sceNetConfigWlanGetDeviceConfig(); +int PS4_SYSV_ABI sceNetConfigWlanInfraGetRssiInfo(); +int PS4_SYSV_ABI sceNetConfigWlanInfraLeave(); +int PS4_SYSV_ABI sceNetConfigWlanInfraScanJoin(); +int PS4_SYSV_ABI sceNetConfigWlanScan(); +int PS4_SYSV_ABI sceNetConfigWlanSetDeviceConfig(); +int PS4_SYSV_ABI sceNetConnect(); +int PS4_SYSV_ABI sceNetControl(); +int PS4_SYSV_ABI sceNetDhcpdStart(); +int PS4_SYSV_ABI sceNetDhcpdStop(); +int PS4_SYSV_ABI sceNetDhcpGetAutoipInfo(); +int PS4_SYSV_ABI sceNetDhcpGetInfo(); +int PS4_SYSV_ABI sceNetDhcpGetInfoEx(); +int PS4_SYSV_ABI sceNetDhcpStart(); +int PS4_SYSV_ABI sceNetDhcpStop(); +int PS4_SYSV_ABI sceNetDumpAbort(); +int PS4_SYSV_ABI sceNetDumpCreate(); +int PS4_SYSV_ABI sceNetDumpDestroy(); +int PS4_SYSV_ABI sceNetDumpRead(); +int PS4_SYSV_ABI sceNetDuplicateIpStart(); +int PS4_SYSV_ABI sceNetDuplicateIpStop(); +int PS4_SYSV_ABI sceNetEpollAbort(); +int PS4_SYSV_ABI sceNetEpollControl(); +int PS4_SYSV_ABI sceNetEpollCreate(); +int PS4_SYSV_ABI sceNetEpollDestroy(); +int PS4_SYSV_ABI sceNetEpollWait(); +int PS4_SYSV_ABI sceNetErrnoLoc(); +int PS4_SYSV_ABI sceNetEtherNtostr(); +int PS4_SYSV_ABI sceNetEtherStrton(); +int PS4_SYSV_ABI sceNetEventCallbackCreate(); +int PS4_SYSV_ABI sceNetEventCallbackDestroy(); +int PS4_SYSV_ABI sceNetEventCallbackGetError(); +int PS4_SYSV_ABI sceNetEventCallbackWaitCB(); +int PS4_SYSV_ABI sceNetFreeAllRouteInfo(); +int PS4_SYSV_ABI sceNetGetArpInfo(); +int PS4_SYSV_ABI sceNetGetDns6Info(); +int PS4_SYSV_ABI sceNetGetDnsInfo(); +int PS4_SYSV_ABI sceNetGetIfList(); +int PS4_SYSV_ABI sceNetGetIfListOnce(); +int PS4_SYSV_ABI sceNetGetIfName(); +int PS4_SYSV_ABI sceNetGetIfnameNumList(); +int PS4_SYSV_ABI sceNetGetMacAddress(); +int PS4_SYSV_ABI sceNetGetMemoryPoolStats(); +int PS4_SYSV_ABI sceNetGetNameToIndex(); +int PS4_SYSV_ABI sceNetGetpeername(); +int PS4_SYSV_ABI sceNetGetRandom(); +int PS4_SYSV_ABI sceNetGetRouteInfo(); +int PS4_SYSV_ABI sceNetGetSockInfo(); +int PS4_SYSV_ABI sceNetGetSockInfo6(); +int PS4_SYSV_ABI sceNetGetsockname(); +int PS4_SYSV_ABI sceNetGetsockopt(); +int PS4_SYSV_ABI sceNetGetStatisticsInfo(); +int PS4_SYSV_ABI sceNetGetStatisticsInfoInternal(); +int PS4_SYSV_ABI sceNetGetSystemTime(); +int PS4_SYSV_ABI sceNetHtonl(); +int PS4_SYSV_ABI sceNetHtonll(); +int PS4_SYSV_ABI sceNetHtons(); +int PS4_SYSV_ABI sceNetInetNtop(); +int PS4_SYSV_ABI sceNetInetNtopWithScopeId(); +int PS4_SYSV_ABI sceNetInetPton(); +int PS4_SYSV_ABI sceNetInetPtonEx(); +int PS4_SYSV_ABI sceNetInetPtonWithScopeId(); +int PS4_SYSV_ABI sceNetInfoDumpStart(); +int PS4_SYSV_ABI sceNetInfoDumpStop(); +int PS4_SYSV_ABI sceNetInit(); +int PS4_SYSV_ABI sceNetInitParam(); +int PS4_SYSV_ABI sceNetIoctl(); +int PS4_SYSV_ABI sceNetListen(); +int PS4_SYSV_ABI sceNetMemoryAllocate(); +int PS4_SYSV_ABI sceNetMemoryFree(); +int PS4_SYSV_ABI sceNetNtohl(); +int PS4_SYSV_ABI sceNetNtohll(); +int PS4_SYSV_ABI sceNetNtohs(); +int PS4_SYSV_ABI sceNetPoolCreate(); +int PS4_SYSV_ABI sceNetPoolDestroy(); +int PS4_SYSV_ABI sceNetPppoeStart(); +int PS4_SYSV_ABI sceNetPppoeStop(); +int PS4_SYSV_ABI sceNetRecv(); +int PS4_SYSV_ABI sceNetRecvfrom(); +int PS4_SYSV_ABI sceNetRecvmsg(); +int PS4_SYSV_ABI sceNetResolverAbort(); +int PS4_SYSV_ABI sceNetResolverConnect(); +int PS4_SYSV_ABI sceNetResolverConnectAbort(); +int PS4_SYSV_ABI sceNetResolverConnectCreate(); +int PS4_SYSV_ABI sceNetResolverConnectDestroy(); +int PS4_SYSV_ABI sceNetResolverCreate(); +int PS4_SYSV_ABI sceNetResolverDestroy(); +int PS4_SYSV_ABI sceNetResolverGetError(); +int PS4_SYSV_ABI sceNetResolverStartAton(); +int PS4_SYSV_ABI sceNetResolverStartAton6(); +int PS4_SYSV_ABI sceNetResolverStartNtoa(); +int PS4_SYSV_ABI sceNetResolverStartNtoa6(); +int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecords(); +int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecordsEx(); +int PS4_SYSV_ABI sceNetSend(); +int PS4_SYSV_ABI sceNetSendmsg(); +int PS4_SYSV_ABI sceNetSendto(); +int PS4_SYSV_ABI sceNetSetDns6Info(); +int PS4_SYSV_ABI sceNetSetDns6InfoToKernel(); +int PS4_SYSV_ABI sceNetSetDnsInfo(); +int PS4_SYSV_ABI sceNetSetDnsInfoToKernel(); +int PS4_SYSV_ABI sceNetSetsockopt(); +int PS4_SYSV_ABI sceNetShowIfconfig(); +int PS4_SYSV_ABI sceNetShowIfconfigForBuffer(); +int PS4_SYSV_ABI sceNetShowIfconfigWithMemory(); +int PS4_SYSV_ABI sceNetShowNetstat(); +int PS4_SYSV_ABI sceNetShowNetstatEx(); +int PS4_SYSV_ABI sceNetShowNetstatExForBuffer(); +int PS4_SYSV_ABI sceNetShowNetstatForBuffer(); +int PS4_SYSV_ABI sceNetShowNetstatWithMemory(); +int PS4_SYSV_ABI sceNetShowPolicy(); +int PS4_SYSV_ABI sceNetShowPolicyWithMemory(); +int PS4_SYSV_ABI sceNetShowRoute(); +int PS4_SYSV_ABI sceNetShowRoute6(); +int PS4_SYSV_ABI sceNetShowRoute6ForBuffer(); +int PS4_SYSV_ABI sceNetShowRoute6WithMemory(); +int PS4_SYSV_ABI sceNetShowRouteForBuffer(); +int PS4_SYSV_ABI sceNetShowRouteWithMemory(); +int PS4_SYSV_ABI sceNetShutdown(); +int PS4_SYSV_ABI sceNetSocket(); +int PS4_SYSV_ABI sceNetSocketAbort(); +int PS4_SYSV_ABI sceNetSocketClose(); +int PS4_SYSV_ABI sceNetSyncCreate(); +int PS4_SYSV_ABI sceNetSyncDestroy(); +int PS4_SYSV_ABI sceNetSyncGet(); +int PS4_SYSV_ABI sceNetSyncSignal(); +int PS4_SYSV_ABI sceNetSyncWait(); +int PS4_SYSV_ABI sceNetSysctl(); +int PS4_SYSV_ABI sceNetTerm(); +int PS4_SYSV_ABI sceNetThreadCreate(); +int PS4_SYSV_ABI sceNetThreadExit(); +int PS4_SYSV_ABI sceNetThreadJoin(); +int PS4_SYSV_ABI sceNetUsleep(); +int PS4_SYSV_ABI Func_0E707A589F751C68(); +int PS4_SYSV_ABI sceNetEmulationGet(); +int PS4_SYSV_ABI sceNetEmulationSet(); + +void RegisterlibSceNet(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Net \ No newline at end of file diff --git a/src/core/libraries/libscenetctl.cpp b/src/core/libraries/libscenetctl.cpp new file mode 100644 index 00000000..cdafbfc2 --- /dev/null +++ b/src/core/libraries/libscenetctl.cpp @@ -0,0 +1,670 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "libscenetctl.h" +#include "common/logging/log.h" +#include "error_codes.h" + +namespace Libraries::NetCtl{ + +int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweClearEventIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweGetInfoIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetInfoV6() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetResultV6() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetStateV6() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlCheckCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlClearEventIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlConnectIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetIfStat() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetInfo() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetNatInfo() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetResult() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetResultIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetState() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetState2IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetStateIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlGetWifiType() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlInit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlScanIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlTerm() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_D8DCB6973537A3DC() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApCheckCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApClearEvent() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApGetConnectInfo() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApGetInfo() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApGetResult() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApGetState() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApInit() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRegisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApStop() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApTerm() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApUnregisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRestart() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpCheckCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpClearEvent() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpGetInfo() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpGetResult() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpGetState() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStart() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStartConf() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStop() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback() +{ + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver * sym) { + LIB_FUNCTION("XtClSOC1xcU", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweCheckCallbackIpcInt ); + LIB_FUNCTION("YALqoY4aeY0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweClearEventIpcInt ); + LIB_FUNCTION("ouyROWhGUbM", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweFinishInternetConnectionTestIpcInt ); + LIB_FUNCTION("G4vltQ0Vs+0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweGetInfoIpcInt ); + LIB_FUNCTION("GqETL5+INhU", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweRegisterCallbackIpcInt ); + LIB_FUNCTION("mEUt-phGd5E", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweSetInternetConnectionTestResultIpcInt ); + LIB_FUNCTION("pQLJV5SEAqk", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweStartInternetConnectionTestBandwidthTestIpcInt ); + LIB_FUNCTION("c+aYh130SV0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweStartInternetConnectionTestIpcInt ); + LIB_FUNCTION("0lViPaTB-R8", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweUnregisterCallbackIpcInt ); + LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6 ); + LIB_FUNCTION("H5yARg37U5g", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6 ); + LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6 ); + LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6 ); + LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6 ); + LIB_FUNCTION("iQw3iQPhvUQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallback ); + LIB_FUNCTION("UF6H6+kjyQs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallbackForLibIpcInt ); + LIB_FUNCTION("vv6g8zoanL4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventForLibIpcInt ); + LIB_FUNCTION("8OJ86vFucfo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventIpcInt ); + LIB_FUNCTION("HCD46HVTyQg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectConfIpcInt ); + LIB_FUNCTION("ID+Gq3Ddzbg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectIpcInt ); + LIB_FUNCTION("aPpic8K75YA", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectWithRetryIpcInt ); + LIB_FUNCTION("9y4IcsJdTCc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlDisableBandwidthManagementIpcInt ); + LIB_FUNCTION("qOefcpoSs0k", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlDisconnectIpcInt ); + LIB_FUNCTION("x9bSmRSE+hc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlEnableBandwidthManagementIpcInt ); + LIB_FUNCTION("eCUIlA2t5CE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetBandwidthInfoIpcInt ); + LIB_FUNCTION("2EfjPXVPk3s", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetEtherLinkMode ); + LIB_FUNCTION("teuK4QnJTGg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetIfStat ); + LIB_FUNCTION("obuxdTiwkF8", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfo ); + LIB_FUNCTION("xstcTqAhTys", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoIpcInt ); + LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6 ); + LIB_FUNCTION("arAQRFlwqaA", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6IpcInt ); + LIB_FUNCTION("JO4yuTuMoKI", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNatInfo ); + LIB_FUNCTION("x+cnsAxKSHo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNatInfoIpcInt ); + LIB_FUNCTION("hhTsdv99azU", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNetEvConfigInfoIpcInt ); + LIB_FUNCTION("0cBgduPRR+M", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResult ); + LIB_FUNCTION("NEtnusbZyAs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultIpcInt ); + LIB_FUNCTION("H5yARg37U5g", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6 ); + LIB_FUNCTION("vdsTa93atXY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6IpcInt ); + LIB_FUNCTION("wP0Ab2maR1Y", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoBssidForSsidListScanIpcInt ); + LIB_FUNCTION("Wn-+887Lt2s", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoBssidIpcInt ); + LIB_FUNCTION("FEdkOG1VbQo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoByBssidIpcInt ); + LIB_FUNCTION("irV8voIAHDw", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoForSsidListScanIpcInt ); + LIB_FUNCTION("L97eAHI0xxs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoForSsidScanIpcInt ); + LIB_FUNCTION("uBPlr0lbuiI", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetState ); + LIB_FUNCTION("JXlI9EZVjf4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetState2IpcInt ); + LIB_FUNCTION("gvnJPMkSoAY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateIpcInt ); + LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6 ); + LIB_FUNCTION("O8Fk4w5MWss", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6IpcInt ); + LIB_FUNCTION("BXW9b3R1Nw4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetWifiType ); + LIB_FUNCTION("gky0+oaNM4k", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlInit ); + LIB_FUNCTION("YtAnCkTR0K4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlIsBandwidthManagementEnabledIpcInt ); + LIB_FUNCTION("UJ+Z7Q+4ck0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallback ); + LIB_FUNCTION("WRvDk2syatE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackForLibIpcInt ); + LIB_FUNCTION("rqkh2kXvLSw", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackIpcInt ); + LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6 ); + LIB_FUNCTION("ipqlpcIqRsQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6IpcInt ); + LIB_FUNCTION("reIsHryCDx4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlScanIpcInt ); + LIB_FUNCTION("LJYiiIS4HB0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlSetErrorNotificationEnabledIpcInt ); + LIB_FUNCTION("DjuqqqV08Nk", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlSetStunWithPaddingFlagIpcInt ); + LIB_FUNCTION("Z4wwCFiBELQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlTerm ); + LIB_FUNCTION("Rqm2OnZMCz0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallback ); + LIB_FUNCTION("urWaUWkEGZg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackForLibIpcInt ); + LIB_FUNCTION("by9cbB7JGJE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackIpcInt ); + LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6 ); + LIB_FUNCTION("Hjxpy28aID8", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6IpcInt ); + LIB_FUNCTION("1HSvkN9oxO4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnsetStunWithPaddingFlagIpcInt ); + LIB_FUNCTION("2Ny2lzU3o9w", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , Func_D8DCB6973537A3DC ); + LIB_FUNCTION("u5oqtlIP+Fw", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallbackForNpToolkit ); + LIB_FUNCTION("saYB0b2ZWtI", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventForNpToolkit ); + LIB_FUNCTION("wIsKy+TfeLs", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackForNpToolkit ); + LIB_FUNCTION("2oUqKR5odGc", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackForNpToolkit ); + LIB_FUNCTION("19Ec7WkMFfQ", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApCheckCallback ); + LIB_FUNCTION("meFMaDpdsVI", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApClearEvent ); + LIB_FUNCTION("hfkLVdXmfnU", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetConnectInfo ); + LIB_FUNCTION("LXADzTIzM9I", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetInfo ); + LIB_FUNCTION("4jkLJc954+Q", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetResult ); + LIB_FUNCTION("AKZOzsb9whc", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetState ); + LIB_FUNCTION("FdN+edNRtiw", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApInit ); + LIB_FUNCTION("pmjobSVHuY0", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRegisterCallback ); + LIB_FUNCTION("r-pOyN6AhsM", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApStop ); + LIB_FUNCTION("cv5Y2efOTeg", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApTerm ); + LIB_FUNCTION("NpTcFtaQ-0E", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApUnregisterCallback ); + LIB_FUNCTION("R-4a9Yh4tG8", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppInitWpaKey ); + LIB_FUNCTION("5oLJoOVBbGU", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppInitWpaKeyForQa ); + LIB_FUNCTION("YtTwZ3pa4aQ", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppStartWithRetry ); + LIB_FUNCTION("sgWeDrEt24U", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppStartWithRetryPid ); + LIB_FUNCTION("amqSGH8l--s", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRestart ); + LIB_FUNCTION("DufQZgH5ISc", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpCheckCallback ); + LIB_FUNCTION("qhZbOi+2qLY", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpClearEvent ); + LIB_FUNCTION("VQl16Q+qXeY", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetInfo ); + LIB_FUNCTION("3pxwYqHzGcw", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetResult ); + LIB_FUNCTION("LEn8FGztKWc", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetState ); + LIB_FUNCTION("ofGsK+xoAaM", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpRegisterCallback ); + LIB_FUNCTION("mjFgpqNavHg", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStart ); + LIB_FUNCTION("HMvaHoZWsn8", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStartConf ); + LIB_FUNCTION("9Dxg7XSlr2s", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStartWithRetry ); + LIB_FUNCTION("6uvAl4RlEyk", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStop ); + LIB_FUNCTION("8eyH37Ns8tk", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpUnregisterCallback ); +}; + +} \ No newline at end of file diff --git a/src/core/libraries/libscenetctl.h b/src/core/libraries/libscenetctl.h new file mode 100644 index 00000000..2edc6058 --- /dev/null +++ b/src/core/libraries/libscenetctl.h @@ -0,0 +1,105 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::NetCtl { + +int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt(); +int PS4_SYSV_ABI sceNetBweClearEventIpcInt(); +int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt(); +int PS4_SYSV_ABI sceNetBweGetInfoIpcInt(); +int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt(); +int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt(); +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt(); +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt(); +int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetInfoV6(); +int PS4_SYSV_ABI sceNetCtlGetResultV6(); +int PS4_SYSV_ABI sceNetCtlGetStateV6(); +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6(); +int PS4_SYSV_ABI sceNetCtlCheckCallback(); +int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt(); +int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt(); +int PS4_SYSV_ABI sceNetCtlClearEventIpcInt(); +int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt(); +int PS4_SYSV_ABI sceNetCtlConnectIpcInt(); +int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt(); +int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt(); +int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt(); +int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode(); +int PS4_SYSV_ABI sceNetCtlGetIfStat(); +int PS4_SYSV_ABI sceNetCtlGetInfo(); +int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt(); +int PS4_SYSV_ABI sceNetCtlGetNatInfo(); +int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetResult(); +int PS4_SYSV_ABI sceNetCtlGetResultIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt(); +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetState(); +int PS4_SYSV_ABI sceNetCtlGetState2IpcInt(); +int PS4_SYSV_ABI sceNetCtlGetStateIpcInt(); +int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt(); +int PS4_SYSV_ABI sceNetCtlGetWifiType(); +int PS4_SYSV_ABI sceNetCtlInit(); +int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt(); +int PS4_SYSV_ABI sceNetCtlRegisterCallback(); +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt(); +int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt(); +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt(); +int PS4_SYSV_ABI sceNetCtlScanIpcInt(); +int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt(); +int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt(); +int PS4_SYSV_ABI sceNetCtlTerm(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallback(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt(); +int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt(); +int PS4_SYSV_ABI Func_D8DCB6973537A3DC(); +int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit(); +int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit(); +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit(); +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit(); +int PS4_SYSV_ABI sceNetCtlApCheckCallback(); +int PS4_SYSV_ABI sceNetCtlApClearEvent(); +int PS4_SYSV_ABI sceNetCtlApGetConnectInfo(); +int PS4_SYSV_ABI sceNetCtlApGetInfo(); +int PS4_SYSV_ABI sceNetCtlApGetResult(); +int PS4_SYSV_ABI sceNetCtlApGetState(); +int PS4_SYSV_ABI sceNetCtlApInit(); +int PS4_SYSV_ABI sceNetCtlApRegisterCallback(); +int PS4_SYSV_ABI sceNetCtlApStop(); +int PS4_SYSV_ABI sceNetCtlApTerm(); +int PS4_SYSV_ABI sceNetCtlApUnregisterCallback(); +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey(); +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa(); +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry(); +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid(); +int PS4_SYSV_ABI sceNetCtlApRestart(); +int PS4_SYSV_ABI sceNetCtlApRpCheckCallback(); +int PS4_SYSV_ABI sceNetCtlApRpClearEvent(); +int PS4_SYSV_ABI sceNetCtlApRpGetInfo(); +int PS4_SYSV_ABI sceNetCtlApRpGetResult(); +int PS4_SYSV_ABI sceNetCtlApRpGetState(); +int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback(); +int PS4_SYSV_ABI sceNetCtlApRpStart(); +int PS4_SYSV_ABI sceNetCtlApRpStartConf(); +int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry(); +int PS4_SYSV_ABI sceNetCtlApRpStop(); +int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback(); + +void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::NetCtl \ No newline at end of file diff --git a/src/core/libraries/libscesavedata.cpp b/src/core/libraries/libscesavedata.cpp new file mode 100644 index 00000000..57ba7b4d --- /dev/null +++ b/src/core/libraries/libscesavedata.cpp @@ -0,0 +1,653 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libscesavedata.h" + +namespace Libraries::SaveData { + +int PS4_SYSV_ABI sceSaveDataAbort() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataBackup() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataBindPsnAccount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataChangeDatabase() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataChangeInternal() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckBackupData() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckCloudData() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckIpmiIfSize() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckSaveDataBroken() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersion() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersionLatest() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataClearProgress() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCopy5() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataCreateUploadData() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebug() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugCleanMount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugCompiledSdkVersion() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugGetThreadId() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDebugTarget() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDelete() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDelete5() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDeleteAllUser() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDeleteCloudData() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDeleteUser() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDirNameSearch() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataDownload() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetAllSize() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetAppLaunchedUser() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetAutoUploadConditions() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetAutoUploadRequestInfo() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetAutoUploadSetting() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetBoundPsnAccountCount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetEventInfo() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetEventResult() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetFormat() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetMountInfo() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetParam() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetProgress() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataCount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetSavePoint() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataInitialize() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataInitialize2() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataInitialize3() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataInitializeForCdlg() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataIsMounted() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataLoadIcon() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataMount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataMount2() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataMount5() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataMountInternal() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataMountSys() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataPromote5() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataRebuildDatabase() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataRegisterEventCallback() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataRestoreBackupData() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSaveIcon() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetEventInfo() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetParam() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataShutdownStart() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSyncCloudList() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataTerminate() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataTransferringMount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataUmount() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataUmountSys() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataUmountWithBackup() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSaveDataUpload() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_02E4C4D201716422() { + LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("dQ2GohUHXzk", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataAbort); + LIB_FUNCTION("z1JA8-iJt3k", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataBackup); + LIB_FUNCTION("kLJQ3XioYiU", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataBindPsnAccount); + LIB_FUNCTION("hHHCPRqA3+g", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataBindPsnAccountForSystemBackup); + LIB_FUNCTION("ykwIZfVD08s", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataChangeDatabase); + LIB_FUNCTION("G0hFeOdRCUs", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataChangeInternal); + LIB_FUNCTION("RQOqDbk3bSU", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckBackupData); + LIB_FUNCTION("rYvLW1z2poM", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckBackupDataForCdlg); + LIB_FUNCTION("v1TrX+3ZB10", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckBackupDataInternal); + LIB_FUNCTION("-eczr5e4dsI", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckCloudData); + LIB_FUNCTION("4OPOZxfVkHA", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckIpmiIfSize); + LIB_FUNCTION("1i0rfc+mfa8", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckSaveDataBroken); + LIB_FUNCTION("p6A1adyQi3E", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckSaveDataVersion); + LIB_FUNCTION("S49B+I96kpk", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCheckSaveDataVersionLatest); + LIB_FUNCTION("Wz-4JZfeO9g", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataClearProgress); + LIB_FUNCTION("YbCO38BOOl4", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataCopy5); + LIB_FUNCTION("kbIIP9aXK9A", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataCreateUploadData); + LIB_FUNCTION("gW6G4HxBBXA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDebug); + LIB_FUNCTION("bYCnxLexU7M", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugCleanMount); + LIB_FUNCTION("hVDqYB8+jkk", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugCompiledSdkVersion); + LIB_FUNCTION("K9gXXlrVLNI", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugCreateSaveDataRoot); + LIB_FUNCTION("5yHFvMwZX2o", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugGetThreadId); + LIB_FUNCTION("UGTldPVEdB4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugRemoveSaveDataRoot); + LIB_FUNCTION("AYBQmnRplrg", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDebugTarget); + LIB_FUNCTION("S1GkePI17zQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDelete); + LIB_FUNCTION("SQWusLoK8Pw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDelete5); + LIB_FUNCTION("pJrlpCgR8h4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDeleteAllUser); + LIB_FUNCTION("fU43mJUgKcM", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDeleteCloudData); + LIB_FUNCTION("uZqc4JpFdeY", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDeleteUser); + LIB_FUNCTION("dyIhnXq-0SM", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDirNameSearch); + LIB_FUNCTION("xJ5NFWC3m+k", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataDirNameSearchInternal); + LIB_FUNCTION("h1nP9EYv3uc", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataDownload); + LIB_FUNCTION("A1ThglSGUwA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetAllSize); + LIB_FUNCTION("KuXcrMAQIMQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetAppLaunchedUser); + LIB_FUNCTION("itZ46iH14Vs", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetAutoUploadConditions); + LIB_FUNCTION("PL20kjAXZZ4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetAutoUploadRequestInfo); + LIB_FUNCTION("G12foE0S77E", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetAutoUploadSetting); + LIB_FUNCTION("PzDtD6eBXIM", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetBoundPsnAccountCount); + LIB_FUNCTION("tu0SDPl+h88", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetClientThreadPriority); + LIB_FUNCTION("6lZYZqQPfkY", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetCloudQuotaInfo); + LIB_FUNCTION("CWlBd2Ay1M4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetDataBaseFilePath); + LIB_FUNCTION("eBSSNIG6hMk", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetEventInfo); + LIB_FUNCTION("j8xKtiFj0SY", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetEventResult); + LIB_FUNCTION("UMpxor4AlKQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetFormat); + LIB_FUNCTION("pc4guaUPVqA", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetMountedSaveDataCount); + LIB_FUNCTION("65VH0Qaaz6s", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetMountInfo); + LIB_FUNCTION("XgvSuIdnMlw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataGetParam); + LIB_FUNCTION("ANmSWUiyyGQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetProgress); + LIB_FUNCTION("SN7rTPHS+Cg", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataCount); + LIB_FUNCTION("7Bt5pBC-Aco", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataMemory); + LIB_FUNCTION("QwOO7vegnV8", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataMemory2); + LIB_FUNCTION("+bRDRotfj0Y", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataRootDir); + LIB_FUNCTION("3luF0xq0DkQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataRootPath); + LIB_FUNCTION("DwAvlQGvf1o", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSaveDataRootUsbPath); + LIB_FUNCTION("kb24-4DLyNo", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetSavePoint); + LIB_FUNCTION("OYmnApJ9q+U", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataGetUpdatedDataCount); + LIB_FUNCTION("ZkZhskCPXFw", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataInitialize); + LIB_FUNCTION("l1NmDeDpNGU", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataInitialize2); + LIB_FUNCTION("TywrFKCoLGY", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataInitialize3); + LIB_FUNCTION("g9uwUI3BlQ8", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataInitializeForCdlg); + LIB_FUNCTION("voAQW45oKuo", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataIsDeletingUsbDb); + LIB_FUNCTION("ieP6jP138Qo", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataIsMounted); + LIB_FUNCTION("cGjO3wM3V28", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataLoadIcon); + LIB_FUNCTION("32HQAQdwM2o", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount); + LIB_FUNCTION("0z45PIH+SNI", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount2); + LIB_FUNCTION("xz0YMi6BfNk", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMount5); + LIB_FUNCTION("msCER7Iibm8", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataMountInternal); + LIB_FUNCTION("-XYmdxjOqyA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataMountSys); + LIB_FUNCTION("uNu7j3pL2mQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataPromote5); + LIB_FUNCTION("SgIY-XYA2Xg", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataRebuildDatabase); + LIB_FUNCTION("hsKd5c21sQc", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataRegisterEventCallback); + LIB_FUNCTION("lU9YRFsgwSU", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataRestoreBackupData); + LIB_FUNCTION("HuToUt1GQ8w", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataRestoreBackupDataForCdlg); + LIB_FUNCTION("aoZKKNjlq3Y", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataRestoreLoadSaveDataMemory); + LIB_FUNCTION("c88Yy54Mx0w", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataSaveIcon); + LIB_FUNCTION("0VFHv-Fa4w8", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetAutoUploadSetting); + LIB_FUNCTION("52pL2GKkdjA", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetEventInfo); + LIB_FUNCTION("85zul--eGXs", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataSetParam); + LIB_FUNCTION("v3vg2+cooYw", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetSaveDataLibraryUser); + LIB_FUNCTION("h3YURzXGSVQ", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetSaveDataMemory); + LIB_FUNCTION("cduy9v4YmT4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetSaveDataMemory2); + LIB_FUNCTION("v7AAAMo0Lz4", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetupSaveDataMemory); + LIB_FUNCTION("oQySEUfgXRA", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSetupSaveDataMemory2); + LIB_FUNCTION("zMgXM79jRhw", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataShutdownStart); + LIB_FUNCTION("+orZm32HB1s", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSupportedFakeBrokenStatus); + LIB_FUNCTION("LMSQUTxmGVg", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSyncCloudList); + LIB_FUNCTION("wiT9jeC7xPw", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataSyncSaveDataMemory); + LIB_FUNCTION("yKDy8S5yLA0", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataTerminate); + LIB_FUNCTION("WAzWTZm1H+I", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataTransferringMount); + LIB_FUNCTION("BMR4F-Uek3E", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUmount); + LIB_FUNCTION("2-8NWLS8QSA", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUmountSys); + LIB_FUNCTION("VwadwBBBJ80", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataUmountWithBackup); + LIB_FUNCTION("v-AK1AxQhS0", "libSceSaveData", 1, "libSceSaveData", 1, 1, + sceSaveDataUnregisterEventCallback); + LIB_FUNCTION("COwz3WBj+5s", "libSceSaveData", 1, "libSceSaveData", 1, 1, sceSaveDataUpload); + LIB_FUNCTION("AuTE0gFxZCI", "libSceSaveData", 1, "libSceSaveData", 1, 1, Func_02E4C4D201716422); +}; + +} // namespace Libraries::SaveData \ No newline at end of file diff --git a/src/core/libraries/libscesavedata.h b/src/core/libraries/libscesavedata.h new file mode 100644 index 00000000..93f902c1 --- /dev/null +++ b/src/core/libraries/libscesavedata.h @@ -0,0 +1,107 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::SaveData { + +int PS4_SYSV_ABI sceSaveDataAbort(); +int PS4_SYSV_ABI sceSaveDataBackup(); +int PS4_SYSV_ABI sceSaveDataBindPsnAccount(); +int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup(); +int PS4_SYSV_ABI sceSaveDataChangeDatabase(); +int PS4_SYSV_ABI sceSaveDataChangeInternal(); +int PS4_SYSV_ABI sceSaveDataCheckBackupData(); +int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg(); +int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal(); +int PS4_SYSV_ABI sceSaveDataCheckCloudData(); +int PS4_SYSV_ABI sceSaveDataCheckIpmiIfSize(); +int PS4_SYSV_ABI sceSaveDataCheckSaveDataBroken(); +int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersion(); +int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersionLatest(); +int PS4_SYSV_ABI sceSaveDataClearProgress(); +int PS4_SYSV_ABI sceSaveDataCopy5(); +int PS4_SYSV_ABI sceSaveDataCreateUploadData(); +int PS4_SYSV_ABI sceSaveDataDebug(); +int PS4_SYSV_ABI sceSaveDataDebugCleanMount(); +int PS4_SYSV_ABI sceSaveDataDebugCompiledSdkVersion(); +int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot(); +int PS4_SYSV_ABI sceSaveDataDebugGetThreadId(); +int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot(); +int PS4_SYSV_ABI sceSaveDataDebugTarget(); +int PS4_SYSV_ABI sceSaveDataDelete(); +int PS4_SYSV_ABI sceSaveDataDelete5(); +int PS4_SYSV_ABI sceSaveDataDeleteAllUser(); +int PS4_SYSV_ABI sceSaveDataDeleteCloudData(); +int PS4_SYSV_ABI sceSaveDataDeleteUser(); +int PS4_SYSV_ABI sceSaveDataDirNameSearch(); +int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal(); +int PS4_SYSV_ABI sceSaveDataDownload(); +int PS4_SYSV_ABI sceSaveDataGetAllSize(); +int PS4_SYSV_ABI sceSaveDataGetAppLaunchedUser(); +int PS4_SYSV_ABI sceSaveDataGetAutoUploadConditions(); +int PS4_SYSV_ABI sceSaveDataGetAutoUploadRequestInfo(); +int PS4_SYSV_ABI sceSaveDataGetAutoUploadSetting(); +int PS4_SYSV_ABI sceSaveDataGetBoundPsnAccountCount(); +int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority(); +int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo(); +int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath(); +int PS4_SYSV_ABI sceSaveDataGetEventInfo(); +int PS4_SYSV_ABI sceSaveDataGetEventResult(); +int PS4_SYSV_ABI sceSaveDataGetFormat(); +int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount(); +int PS4_SYSV_ABI sceSaveDataGetMountInfo(); +int PS4_SYSV_ABI sceSaveDataGetParam(); +int PS4_SYSV_ABI sceSaveDataGetProgress(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataCount(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath(); +int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath(); +int PS4_SYSV_ABI sceSaveDataGetSavePoint(); +int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount(); +int PS4_SYSV_ABI sceSaveDataInitialize(); +int PS4_SYSV_ABI sceSaveDataInitialize2(); +int PS4_SYSV_ABI sceSaveDataInitialize3(); +int PS4_SYSV_ABI sceSaveDataInitializeForCdlg(); +int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb(); +int PS4_SYSV_ABI sceSaveDataIsMounted(); +int PS4_SYSV_ABI sceSaveDataLoadIcon(); +int PS4_SYSV_ABI sceSaveDataMount(); +int PS4_SYSV_ABI sceSaveDataMount2(); +int PS4_SYSV_ABI sceSaveDataMount5(); +int PS4_SYSV_ABI sceSaveDataMountInternal(); +int PS4_SYSV_ABI sceSaveDataMountSys(); +int PS4_SYSV_ABI sceSaveDataPromote5(); +int PS4_SYSV_ABI sceSaveDataRebuildDatabase(); +int PS4_SYSV_ABI sceSaveDataRegisterEventCallback(); +int PS4_SYSV_ABI sceSaveDataRestoreBackupData(); +int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg(); +int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory(); +int PS4_SYSV_ABI sceSaveDataSaveIcon(); +int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting(); +int PS4_SYSV_ABI sceSaveDataSetEventInfo(); +int PS4_SYSV_ABI sceSaveDataSetParam(); +int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser(); +int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory(); +int PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2(); +int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory(); +int PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2(); +int PS4_SYSV_ABI sceSaveDataShutdownStart(); +int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus(); +int PS4_SYSV_ABI sceSaveDataSyncCloudList(); +int PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory(); +int PS4_SYSV_ABI sceSaveDataTerminate(); +int PS4_SYSV_ABI sceSaveDataTransferringMount(); +int PS4_SYSV_ABI sceSaveDataUmount(); +int PS4_SYSV_ABI sceSaveDataUmountSys(); +int PS4_SYSV_ABI sceSaveDataUmountWithBackup(); +int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback(); +int PS4_SYSV_ABI sceSaveDataUpload(); +int PS4_SYSV_ABI Func_02E4C4D201716422(); + +void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::SaveData \ No newline at end of file diff --git a/src/core/libraries/libscessl.cpp b/src/core/libraries/libscessl.cpp new file mode 100644 index 00000000..ae1e607e --- /dev/null +++ b/src/core/libraries/libscessl.cpp @@ -0,0 +1,1284 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libscessl.h" + +namespace Libraries::Ssl { + +int PS4_SYSV_ABI CA_MGMT_allocCertDistinguishedName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_certDistinguishedNameCompare() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_convertKeyBlobToPKCS8Key() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_convertKeyDER() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_convertKeyPEM() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_convertPKCS8KeyToKeyBlob() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_convertProtectedPKCS8KeyToKeyBlob() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_decodeCertificate() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_enumAltName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_enumCrl() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractAllCertDistinguishedName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractBasicConstraint() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractCertASN1Name() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractCertTimes() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractKeyBlobEx() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractKeyBlobTypeEx() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractPublicKeyInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractSerialNum() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_extractSignature() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_free() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedNameOnStack() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_freeCertificate() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_freeKeyBlob() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_freeSearchDetails() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_getCertSignAlgoType() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_keyBlobToDER() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_keyBlobToPEM() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_makeKeyBlobEx() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_rawVerifyOID() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_reorderChain() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_returnCertificatePrints() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_verifyCertWithKeyBlob() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CA_MGMT_verifySignature() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_checkCertificateIssuer() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_checkCertificateIssuer2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_checkCertificateIssuerSerialNumber() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_CompSubjectAltNames() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_CompSubjectAltNames2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_CompSubjectAltNamesExact() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_CompSubjectCommonName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_CompSubjectCommonName2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_ComputeBufferHash() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_decryptRSASignature() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_decryptRSASignatureBuffer() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_enumerateAltName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_enumerateAltName2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_enumerateCRL() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_enumerateCRL2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_enumerateCRLAux() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractAllDistinguishedNames() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractDistinguishedNames() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractDistinguishedNames2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractDistinguishedNamesFromName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractRSAKey() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractSerialNum() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractSerialNum2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractValidityTime() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_extractValidityTime2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertExtension() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateExtensions() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateExtensions2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateKeyUsage() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateKeyUsage2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateSubject() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertificateSubject2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getCertSignAlgoType() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_GetCertTime() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getNumberOfChild() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getRSASignatureAlgo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getSignatureItem() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getSubjectCommonName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_getSubjectCommonName2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_isRootCertificate() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_isRootCertificate2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_rawVerifyOID() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_rawVerifyOID2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfoCert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addCertAuthority() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addIdentity() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addIdentityNakedKey() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addIdentityPSK() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addIdentityWithCertificateChain() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_addTrustPoint() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_createStore() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findCertBySubject() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeFirst() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeNext() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainFirst() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainNext() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_findPskByIdentity() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_releaseStore() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_traversePskListHead() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_STORE_traversePskListNext() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_validateCertificate() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_validateCertificateWithConf() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_VerifyCertificatePolicies() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_VerifyCertificatePolicies2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_verifySignature() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_VerifyValidityTime() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_VerifyValidityTime2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CERT_VerifyValidityTimeWithConf() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CRYPTO_initAsymmetricKey() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI CRYPTO_uninitAsymmetricKey() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI GC_createInstanceIDs() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getCertSigAlgo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI MOCANA_freeMocana() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI MOCANA_initMocana() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI RSA_verifySignature() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslCheckRecvPending() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslClose() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslConnect() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslCreateSslConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslDeleteSslConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslDisableOption() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslDisableOptionInternal() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslDisableOptionInternalInsecure() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslEnableOption() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslEnableOptionInternal() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslFreeCaCerts() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslFreeCaList() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslFreeSslCertName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetCaCerts() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetCaList() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetIssuerName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetMemoryPoolStats() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetNameEntryCount() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetNameEntryInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetNanoSSLModuleId() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetNotAfter() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetNotBefore() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetSerialNumber() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetSslError() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslGetSubjectName() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslInit() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslLoadCert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslLoadRootCACert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslRecv() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslReuseConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslSend() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslSetMinSslVersion() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslSetSslVersion() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslSetVerifyCallback() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslShowMemoryStat() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslTerm() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSslUnloadCert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_acceptConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_acceptConnectionCommon() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_assignCertificateStore() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_acceptConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_closeConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_connect() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_connectCommon() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_getRecvBuffer() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_getSendBuffer() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_init() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_initServer() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_recvMessage() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_recvMessage2() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_sendMessage() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_sendMessagePending() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ASYNC_start() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_closeConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_connect() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_connectWithCfgParam() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_enableCiphers() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_findConnectionInstance() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getCipherInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getClientRandom() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getClientSessionInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getCookie() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getNextSessionId() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getServerRandom() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSessionCache() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSessionFlags() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSessionInfo() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSessionStatus() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSocketId() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_getSSLTLSVersion() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_init() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_initiateRehandshake() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_initServerCert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_ioctl() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_isSessionSSL() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_lockSessionCacheMutex() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_lookupAlert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_negotiateConnection() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_recv() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_recvPending() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_releaseTables() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_retrieveServerNameList() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_rngFun() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_send() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_sendAlert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_sendPending() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_setCookie() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_setServerCert() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_setServerNameList() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_setSessionFlags() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_shutdown() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_sslSettings() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI SSL_validateCertParam() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI VLONG_freeVlongQueue() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_22E76E60BC0587D7() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_28F8791A771D39C7() { + LOG_ERROR(Lib_Ssl, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceSsl(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("Pgt0gg14ewU", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_allocCertDistinguishedName); + LIB_FUNCTION("wJ5jCpkCv-c", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_certDistinguishedNameCompare); + LIB_FUNCTION("Vc2tb-mWu78", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_convertKeyBlobToPKCS8Key); + LIB_FUNCTION("IizpdlgPdpU", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_convertKeyDER); + LIB_FUNCTION("Y-5sBnpVclY", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_convertKeyPEM); + LIB_FUNCTION("jb6LuBv9weg", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_convertPKCS8KeyToKeyBlob); + LIB_FUNCTION("ExsvtKwhWoM", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_convertProtectedPKCS8KeyToKeyBlob); + LIB_FUNCTION("AvoadUUK03A", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_decodeCertificate); + LIB_FUNCTION("S0DCFBqmhQY", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_enumAltName); + LIB_FUNCTION("Xt+SprLPiVQ", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_enumCrl); + LIB_FUNCTION("4HzS6Vkd-uU", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_extractAllCertDistinguishedName); + LIB_FUNCTION("W80mmhRKtH8", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractBasicConstraint); + LIB_FUNCTION("7+F9pr5g26Q", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractCertASN1Name); + LIB_FUNCTION("KsvuhF--f6k", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractCertTimes); + LIB_FUNCTION("Md+HYkCBZB4", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractKeyBlobEx); + LIB_FUNCTION("rFiChDgHkGQ", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractKeyBlobTypeEx); + LIB_FUNCTION("9bKYzKP6kYU", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractPublicKeyInfo); + LIB_FUNCTION("xXCqbDBx6mA", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractSerialNum); + LIB_FUNCTION("xakUpzS9qv0", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_extractSignature); + LIB_FUNCTION("m7EXDQRv7NU", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_free); + LIB_FUNCTION("64t1HKepy1Q", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_freeCertDistinguishedName); + LIB_FUNCTION("d7AAqdK2IDo", "libSceSsl", 1, "libSceSsl", 1, 1, + CA_MGMT_freeCertDistinguishedNameOnStack); + LIB_FUNCTION("PysF6pUcK-o", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_freeCertificate); + LIB_FUNCTION("ipLIammTj2Q", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_freeKeyBlob); + LIB_FUNCTION("C05CUtDViqU", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_freeSearchDetails); + LIB_FUNCTION("tq511UiaNlE", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_getCertSignAlgoType); + LIB_FUNCTION("1e46hRscIE8", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_keyBlobToDER); + LIB_FUNCTION("5U2j47T1l70", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_keyBlobToPEM); + LIB_FUNCTION("+oCOy8+4at8", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_makeKeyBlobEx); + LIB_FUNCTION("YMbRl6PNq5U", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_rawVerifyOID); + LIB_FUNCTION("O+JTn8Dwan8", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_reorderChain); + LIB_FUNCTION("he6CvWiX3iM", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_returnCertificatePrints); + LIB_FUNCTION("w5ZBRGN1lzY", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_verifyCertWithKeyBlob); + LIB_FUNCTION("5e5rj-coUv8", "libSceSsl", 1, "libSceSsl", 1, 1, CA_MGMT_verifySignature); + LIB_FUNCTION("6nH53ruuckc", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_checkCertificateIssuer); + LIB_FUNCTION("MB3EExhoaJQ", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_checkCertificateIssuer2); + LIB_FUNCTION("sDUV9VsqJD8", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_checkCertificateIssuerSerialNumber); + LIB_FUNCTION("FXCfp5CwcPk", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_CompSubjectAltNames); + LIB_FUNCTION("szJ8gsZdoHE", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_CompSubjectAltNames2); + LIB_FUNCTION("1aewkTBcGEY", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_CompSubjectAltNamesExact); + LIB_FUNCTION("gdWmmelQC1k", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_CompSubjectCommonName); + LIB_FUNCTION("6Z-n6acrhTs", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_CompSubjectCommonName2); + LIB_FUNCTION("p12OhhUCGEE", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_ComputeBufferHash); + LIB_FUNCTION("5G+Z9vXPWYU", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_decryptRSASignature); + LIB_FUNCTION("WZCBPnvf0fw", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_decryptRSASignatureBuffer); + LIB_FUNCTION("AvjnXHAa7G0", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_enumerateAltName); + LIB_FUNCTION("goUd71Bv0lk", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_enumerateAltName2); + LIB_FUNCTION("tf3dP8kVauc", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_enumerateCRL); + LIB_FUNCTION("noRFMfbcI-g", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_enumerateCRL2); + LIB_FUNCTION("Xy4cdu44Xr0", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_enumerateCRLAux); + LIB_FUNCTION("2FPKT8OxHxo", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_extractAllDistinguishedNames); + LIB_FUNCTION("xyd+kSAhtSw", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractDistinguishedNames); + LIB_FUNCTION("BQIv6mcPFRM", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractDistinguishedNames2); + LIB_FUNCTION("nxcdqUGDgW8", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_extractDistinguishedNamesFromName); + LIB_FUNCTION("u82YRvIENeo", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractRSAKey); + LIB_FUNCTION("HBWarJFXoCM", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractSerialNum); + LIB_FUNCTION("8Lemumnt1-8", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractSerialNum2); + LIB_FUNCTION("JhanUiHOg-M", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractValidityTime); + LIB_FUNCTION("6ocfVwswH-E", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_extractValidityTime2); + LIB_FUNCTION("8FqgR3V7gHs", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertExtension); + LIB_FUNCTION("sRIARmcXPHE", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateExtensions); + LIB_FUNCTION("ABAA2f3PM8k", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateExtensions2); + LIB_FUNCTION("CATkBsr20tY", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_getCertificateIssuerSerialNumber); + LIB_FUNCTION("JpnKObUJsxQ", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_getCertificateIssuerSerialNumber2); + LIB_FUNCTION("jp75ki1UzRU", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateKeyUsage); + LIB_FUNCTION("prSVrFdvQiU", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateKeyUsage2); + LIB_FUNCTION("8+UPqcEgsYg", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateSubject); + LIB_FUNCTION("X-rqVhPnKJI", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertificateSubject2); + LIB_FUNCTION("Pt3o1t+hh1g", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getCertSignAlgoType); + LIB_FUNCTION("oNJNApmHV+M", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_GetCertTime); + LIB_FUNCTION("GCPUCV9k1Mg", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getNumberOfChild); + LIB_FUNCTION("lCB1AE4xSkE", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getRSASignatureAlgo); + LIB_FUNCTION("+7U74Zy7gKg", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getSignatureItem); + LIB_FUNCTION("hOABTkhp6NM", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getSubjectCommonName); + LIB_FUNCTION("3CECWZfBTVg", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_getSubjectCommonName2); + LIB_FUNCTION("OP-VhFdtkmo", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_isRootCertificate); + LIB_FUNCTION("0iwGE4M4DU8", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_isRootCertificate2); + LIB_FUNCTION("pWg3+mTkoTI", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_rawVerifyOID); + LIB_FUNCTION("HofoEUZ5mOM", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_rawVerifyOID2); + LIB_FUNCTION("w2lGr-89zLc", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_setKeyFromSubjectPublicKeyInfo); + LIB_FUNCTION("OeGeb9Njons", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_setKeyFromSubjectPublicKeyInfoCert); + LIB_FUNCTION("N+UDju8zxtE", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_addCertAuthority); + LIB_FUNCTION("pIZfvPaYmrs", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_addIdentity); + LIB_FUNCTION("D6QBgLq-nlc", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_addIdentityNakedKey); + LIB_FUNCTION("uAHc6pgeFaQ", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_addIdentityPSK); + LIB_FUNCTION("xdxuhUkYalI", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_STORE_addIdentityWithCertificateChain); + LIB_FUNCTION("OcZJcxANLfw", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_addTrustPoint); + LIB_FUNCTION("gu0eRZMqTu8", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_createStore); + LIB_FUNCTION("s1tJ1zBkky4", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_findCertBySubject); + LIB_FUNCTION("4aXDehFZLDA", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_STORE_findIdentityByTypeFirst); + LIB_FUNCTION("K-g87UhrYQ8", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_STORE_findIdentityByTypeNext); + LIB_FUNCTION("ULOVCAVPJE4", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_STORE_findIdentityCertChainFirst); + LIB_FUNCTION("uS9P+bSWOC0", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_STORE_findIdentityCertChainNext); + LIB_FUNCTION("k3RI-YRkW-M", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_findPskByIdentity); + LIB_FUNCTION("AloU5nLupdU", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_releaseStore); + LIB_FUNCTION("gAHkf68L6+0", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_traversePskListHead); + LIB_FUNCTION("w2CtqF+x7og", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_STORE_traversePskListNext); + LIB_FUNCTION("GTSbNvpE1fQ", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_validateCertificate); + LIB_FUNCTION("j6Wk8AtmVQM", "libSceSsl", 1, "libSceSsl", 1, 1, + CERT_validateCertificateWithConf); + LIB_FUNCTION("wdl-XapuxKU", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_VerifyCertificatePolicies); + LIB_FUNCTION("BQah1z-QS-w", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_VerifyCertificatePolicies2); + LIB_FUNCTION("GPRMLcwyslw", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_verifySignature); + LIB_FUNCTION("CAgB8oEGwsY", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_VerifyValidityTime); + LIB_FUNCTION("3wferxuMV6Y", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_VerifyValidityTime2); + LIB_FUNCTION("UO2a3+5CCCs", "libSceSsl", 1, "libSceSsl", 1, 1, CERT_VerifyValidityTimeWithConf); + LIB_FUNCTION("PRWr3-ytpdg", "libSceSsl", 1, "libSceSsl", 1, 1, CRYPTO_initAsymmetricKey); + LIB_FUNCTION("cW7VCIMCh9A", "libSceSsl", 1, "libSceSsl", 1, 1, CRYPTO_uninitAsymmetricKey); + LIB_FUNCTION("u+brAYVFGUs", "libSceSsl", 1, "libSceSsl", 1, 1, GC_createInstanceIDs); + LIB_FUNCTION("pOmcRglskbI", "libSceSsl", 1, "libSceSsl", 1, 1, getCertSigAlgo); + LIB_FUNCTION("uBqy-2-dQ-A", "libSceSsl", 1, "libSceSsl", 1, 1, MOCANA_freeMocana); + LIB_FUNCTION("U3NHH12yORo", "libSceSsl", 1, "libSceSsl", 1, 1, MOCANA_initMocana); + LIB_FUNCTION("pBwtarKd7eg", "libSceSsl", 1, "libSceSsl", 1, 1, RSA_verifySignature); + LIB_FUNCTION("1VM0h1JrUfA", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslCheckRecvPending); + LIB_FUNCTION("viRXSHZYd0c", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslClose); + LIB_FUNCTION("zXvd6iNyfgc", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslConnect); + LIB_FUNCTION("P14ATpXc4J8", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslCreateSslConnection); + LIB_FUNCTION("hwrHV6Pprk4", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslDeleteSslConnection); + LIB_FUNCTION("iLKz4+ukLqk", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslDisableOption); + LIB_FUNCTION("-WqxBRAUVM4", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslDisableOptionInternal); + LIB_FUNCTION("w1+L-27nYas", "libSceSsl", 1, "libSceSsl", 1, 1, + sceSslDisableOptionInternalInsecure); + LIB_FUNCTION("m-zPyAsIpco", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslEnableOption); + LIB_FUNCTION("g-zCwUKstEQ", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslEnableOptionInternal); + LIB_FUNCTION("qIvLs0gYxi0", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslFreeCaCerts); + LIB_FUNCTION("+DzXseDVkeI", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslFreeCaList); + LIB_FUNCTION("RwXD8grHZHM", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslFreeSslCertName); + LIB_FUNCTION("TDfQqO-gMbY", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetCaCerts); + LIB_FUNCTION("qOn+wm28wmA", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetCaList); + LIB_FUNCTION("7whYpYfHP74", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetIssuerName); + LIB_FUNCTION("-PoIzr3PEk0", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetMemoryPoolStats); + LIB_FUNCTION("R1ePzopYPYM", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetNameEntryCount); + LIB_FUNCTION("7RBSTKGrmDA", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetNameEntryInfo); + LIB_FUNCTION("AzUipl-DpIw", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetNanoSSLModuleId); + LIB_FUNCTION("xHpt6+2pGYk", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetNotAfter); + LIB_FUNCTION("Eo0S65Jy28Q", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetNotBefore); + LIB_FUNCTION("DOwXL+FQMEY", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetSerialNumber); + LIB_FUNCTION("0XcZknp7-Wc", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetSslError); + LIB_FUNCTION("dQReuBX9sD8", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslGetSubjectName); + LIB_FUNCTION("hdpVEUDFW3s", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslInit); + LIB_FUNCTION("Ab7+DH+gYyM", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslLoadCert); + LIB_FUNCTION("3-643mGVFJo", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslLoadRootCACert); + LIB_FUNCTION("hi0veU3L2pU", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslRecv); + LIB_FUNCTION("50R2xYaYZwE", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslReuseConnection); + LIB_FUNCTION("p5bM5PPufFY", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslSend); + LIB_FUNCTION("QWSxBzf6lAg", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslSetMinSslVersion); + LIB_FUNCTION("bKaEtQnoUuQ", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslSetSslVersion); + LIB_FUNCTION("E4a-ahM57QQ", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslSetVerifyCallback); + LIB_FUNCTION("lnHFrZV5zAY", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslShowMemoryStat); + LIB_FUNCTION("0K1yQ6Lv-Yc", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslTerm); + LIB_FUNCTION("UQ+3Qu7v3cA", "libSceSsl", 1, "libSceSsl", 1, 1, sceSslUnloadCert); + LIB_FUNCTION("26lYor6xrR4", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_acceptConnection); + LIB_FUNCTION("iHBiYOSciqY", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_acceptConnectionCommon); + LIB_FUNCTION("budJurAYNHc", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_assignCertificateStore); + LIB_FUNCTION("dCRcdgdoIEI", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_acceptConnection); + LIB_FUNCTION("KI5jhdvg2S8", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_closeConnection); + LIB_FUNCTION("hk+NcQTQlqI", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_connect); + LIB_FUNCTION("rKD5kXcvN0E", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_connectCommon); + LIB_FUNCTION("Fxq5MuWRkSw", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_getRecvBuffer); + LIB_FUNCTION("vCpt1jyL6C4", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_getSendBuffer); + LIB_FUNCTION("wZp1hBtjV1I", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_init); + LIB_FUNCTION("P+O-4XCIODs", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_initServer); + LIB_FUNCTION("GfDzwBDRl3M", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_recvMessage); + LIB_FUNCTION("oM5w6Fb4TWM", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_recvMessage2); + LIB_FUNCTION("dim5NDlc7Vs", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_sendMessage); + LIB_FUNCTION("Qq0o-+hobOI", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_sendMessagePending); + LIB_FUNCTION("y+ZFCsZYNME", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ASYNC_start); + LIB_FUNCTION("5g9cNS3IFCk", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_closeConnection); + LIB_FUNCTION("i9AvJK-l5Jk", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_connect); + LIB_FUNCTION("mgs+n71u35Y", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_connectWithCfgParam); + LIB_FUNCTION("4hPwsDmVKZc", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_enableCiphers); + LIB_FUNCTION("yUd2ukhZLJI", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_findConnectionInstance); + LIB_FUNCTION("J7LWSdYo0Zg", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getCipherInfo); + LIB_FUNCTION("kRb0lquIrj0", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getClientRandom); + LIB_FUNCTION("sSD8SHia8Zc", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getClientSessionInfo); + LIB_FUNCTION("eT7n5lcEYCc", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getCookie); + LIB_FUNCTION("2Irwf6Oqt4E", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getNextSessionId); + LIB_FUNCTION("s9qIeprVILk", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getServerRandom); + LIB_FUNCTION("NRoSvM1VPm8", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSessionCache); + LIB_FUNCTION("dHosoPLXaMw", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSessionFlags); + LIB_FUNCTION("7QgvTqUGFlU", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSessionInfo); + LIB_FUNCTION("ufoBDuHGOlM", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSessionStatus); + LIB_FUNCTION("EAoybreRrGU", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSocketId); + LIB_FUNCTION("ElUzZAXIvY0", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_getSSLTLSVersion); + LIB_FUNCTION("Wi9eDU54UCU", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_init); + LIB_FUNCTION("BSqmh5B4KTg", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_initiateRehandshake); + LIB_FUNCTION("xIFe7m4wqX4", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_initServerCert); + LIB_FUNCTION("zlMZOG3VDYg", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_ioctl); + LIB_FUNCTION("fje5RYUa+2g", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_isSessionSSL); + LIB_FUNCTION("IKENWUUd8bk", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_lockSessionCacheMutex); + LIB_FUNCTION("n6-12LafAeA", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_lookupAlert); + LIB_FUNCTION("H4Z3ShBNjSA", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_negotiateConnection); + LIB_FUNCTION("9PTAJclcW50", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_recv); + LIB_FUNCTION("NrZz0ZgQrao", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_recvPending); + LIB_FUNCTION("SHInb+l58Bs", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_releaseTables); + LIB_FUNCTION("f0MBRCQeOEg", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_retrieveServerNameList); + LIB_FUNCTION("6J0PLGaYl0Y", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_rngFun); + LIB_FUNCTION("MoaZ6-hDS-k", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_send); + LIB_FUNCTION("H02lfd0hCG0", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_sendAlert); + LIB_FUNCTION("nXlhepw9ztI", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_sendPending); + LIB_FUNCTION("Bf0pzkQc6CU", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_setCookie); + LIB_FUNCTION("dSP1n53RtVw", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_setServerCert); + LIB_FUNCTION("kNIvrkD-XJk", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_setServerNameList); + LIB_FUNCTION("pbTq-nEsN1w", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_setSessionFlags); + LIB_FUNCTION("-UDxVMs9h9M", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_shutdown); + LIB_FUNCTION("nH9FVvfZhCs", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_sslSettings); + LIB_FUNCTION("2Bd7UoCRhQ8", "libSceSsl", 1, "libSceSsl", 1, 1, SSL_validateCertParam); + LIB_FUNCTION("wcVuyTUr5ys", "libSceSsl", 1, "libSceSsl", 1, 1, VLONG_freeVlongQueue); + LIB_FUNCTION("IuduYLwFh9c", "libSceSsl", 1, "libSceSsl", 1, 1, Func_22E76E60BC0587D7); + LIB_FUNCTION("KPh5GncdOcc", "libSceSsl", 1, "libSceSsl", 1, 1, Func_28F8791A771D39C7); +}; + +} // namespace Libraries::Ssl \ No newline at end of file diff --git a/src/core/libraries/libscessl.h b/src/core/libraries/libscessl.h new file mode 100644 index 00000000..06eefd21 --- /dev/null +++ b/src/core/libraries/libscessl.h @@ -0,0 +1,220 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::Ssl { + +int PS4_SYSV_ABI CA_MGMT_allocCertDistinguishedName(); +int PS4_SYSV_ABI CA_MGMT_certDistinguishedNameCompare(); +int PS4_SYSV_ABI CA_MGMT_convertKeyBlobToPKCS8Key(); +int PS4_SYSV_ABI CA_MGMT_convertKeyDER(); +int PS4_SYSV_ABI CA_MGMT_convertKeyPEM(); +int PS4_SYSV_ABI CA_MGMT_convertPKCS8KeyToKeyBlob(); +int PS4_SYSV_ABI CA_MGMT_convertProtectedPKCS8KeyToKeyBlob(); +int PS4_SYSV_ABI CA_MGMT_decodeCertificate(); +int PS4_SYSV_ABI CA_MGMT_enumAltName(); +int PS4_SYSV_ABI CA_MGMT_enumCrl(); +int PS4_SYSV_ABI CA_MGMT_extractAllCertDistinguishedName(); +int PS4_SYSV_ABI CA_MGMT_extractBasicConstraint(); +int PS4_SYSV_ABI CA_MGMT_extractCertASN1Name(); +int PS4_SYSV_ABI CA_MGMT_extractCertTimes(); +int PS4_SYSV_ABI CA_MGMT_extractKeyBlobEx(); +int PS4_SYSV_ABI CA_MGMT_extractKeyBlobTypeEx(); +int PS4_SYSV_ABI CA_MGMT_extractPublicKeyInfo(); +int PS4_SYSV_ABI CA_MGMT_extractSerialNum(); +int PS4_SYSV_ABI CA_MGMT_extractSignature(); +int PS4_SYSV_ABI CA_MGMT_free(); +int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedName(); +int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedNameOnStack(); +int PS4_SYSV_ABI CA_MGMT_freeCertificate(); +int PS4_SYSV_ABI CA_MGMT_freeKeyBlob(); +int PS4_SYSV_ABI CA_MGMT_freeSearchDetails(); +int PS4_SYSV_ABI CA_MGMT_getCertSignAlgoType(); +int PS4_SYSV_ABI CA_MGMT_keyBlobToDER(); +int PS4_SYSV_ABI CA_MGMT_keyBlobToPEM(); +int PS4_SYSV_ABI CA_MGMT_makeKeyBlobEx(); +int PS4_SYSV_ABI CA_MGMT_rawVerifyOID(); +int PS4_SYSV_ABI CA_MGMT_reorderChain(); +int PS4_SYSV_ABI CA_MGMT_returnCertificatePrints(); +int PS4_SYSV_ABI CA_MGMT_verifyCertWithKeyBlob(); +int PS4_SYSV_ABI CA_MGMT_verifySignature(); +int PS4_SYSV_ABI CERT_checkCertificateIssuer(); +int PS4_SYSV_ABI CERT_checkCertificateIssuer2(); +int PS4_SYSV_ABI CERT_checkCertificateIssuerSerialNumber(); +int PS4_SYSV_ABI CERT_CompSubjectAltNames(); +int PS4_SYSV_ABI CERT_CompSubjectAltNames2(); +int PS4_SYSV_ABI CERT_CompSubjectAltNamesExact(); +int PS4_SYSV_ABI CERT_CompSubjectCommonName(); +int PS4_SYSV_ABI CERT_CompSubjectCommonName2(); +int PS4_SYSV_ABI CERT_ComputeBufferHash(); +int PS4_SYSV_ABI CERT_decryptRSASignature(); +int PS4_SYSV_ABI CERT_decryptRSASignatureBuffer(); +int PS4_SYSV_ABI CERT_enumerateAltName(); +int PS4_SYSV_ABI CERT_enumerateAltName2(); +int PS4_SYSV_ABI CERT_enumerateCRL(); +int PS4_SYSV_ABI CERT_enumerateCRL2(); +int PS4_SYSV_ABI CERT_enumerateCRLAux(); +int PS4_SYSV_ABI CERT_extractAllDistinguishedNames(); +int PS4_SYSV_ABI CERT_extractDistinguishedNames(); +int PS4_SYSV_ABI CERT_extractDistinguishedNames2(); +int PS4_SYSV_ABI CERT_extractDistinguishedNamesFromName(); +int PS4_SYSV_ABI CERT_extractRSAKey(); +int PS4_SYSV_ABI CERT_extractSerialNum(); +int PS4_SYSV_ABI CERT_extractSerialNum2(); +int PS4_SYSV_ABI CERT_extractValidityTime(); +int PS4_SYSV_ABI CERT_extractValidityTime2(); +int PS4_SYSV_ABI CERT_getCertExtension(); +int PS4_SYSV_ABI CERT_getCertificateExtensions(); +int PS4_SYSV_ABI CERT_getCertificateExtensions2(); +int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber(); +int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber2(); +int PS4_SYSV_ABI CERT_getCertificateKeyUsage(); +int PS4_SYSV_ABI CERT_getCertificateKeyUsage2(); +int PS4_SYSV_ABI CERT_getCertificateSubject(); +int PS4_SYSV_ABI CERT_getCertificateSubject2(); +int PS4_SYSV_ABI CERT_getCertSignAlgoType(); +int PS4_SYSV_ABI CERT_GetCertTime(); +int PS4_SYSV_ABI CERT_getNumberOfChild(); +int PS4_SYSV_ABI CERT_getRSASignatureAlgo(); +int PS4_SYSV_ABI CERT_getSignatureItem(); +int PS4_SYSV_ABI CERT_getSubjectCommonName(); +int PS4_SYSV_ABI CERT_getSubjectCommonName2(); +int PS4_SYSV_ABI CERT_isRootCertificate(); +int PS4_SYSV_ABI CERT_isRootCertificate2(); +int PS4_SYSV_ABI CERT_rawVerifyOID(); +int PS4_SYSV_ABI CERT_rawVerifyOID2(); +int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfo(); +int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfoCert(); +int PS4_SYSV_ABI CERT_STORE_addCertAuthority(); +int PS4_SYSV_ABI CERT_STORE_addIdentity(); +int PS4_SYSV_ABI CERT_STORE_addIdentityNakedKey(); +int PS4_SYSV_ABI CERT_STORE_addIdentityPSK(); +int PS4_SYSV_ABI CERT_STORE_addIdentityWithCertificateChain(); +int PS4_SYSV_ABI CERT_STORE_addTrustPoint(); +int PS4_SYSV_ABI CERT_STORE_createStore(); +int PS4_SYSV_ABI CERT_STORE_findCertBySubject(); +int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeFirst(); +int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeNext(); +int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainFirst(); +int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainNext(); +int PS4_SYSV_ABI CERT_STORE_findPskByIdentity(); +int PS4_SYSV_ABI CERT_STORE_releaseStore(); +int PS4_SYSV_ABI CERT_STORE_traversePskListHead(); +int PS4_SYSV_ABI CERT_STORE_traversePskListNext(); +int PS4_SYSV_ABI CERT_validateCertificate(); +int PS4_SYSV_ABI CERT_validateCertificateWithConf(); +int PS4_SYSV_ABI CERT_VerifyCertificatePolicies(); +int PS4_SYSV_ABI CERT_VerifyCertificatePolicies2(); +int PS4_SYSV_ABI CERT_verifySignature(); +int PS4_SYSV_ABI CERT_VerifyValidityTime(); +int PS4_SYSV_ABI CERT_VerifyValidityTime2(); +int PS4_SYSV_ABI CERT_VerifyValidityTimeWithConf(); +int PS4_SYSV_ABI CRYPTO_initAsymmetricKey(); +int PS4_SYSV_ABI CRYPTO_uninitAsymmetricKey(); +int PS4_SYSV_ABI GC_createInstanceIDs(); +int PS4_SYSV_ABI getCertSigAlgo(); +int PS4_SYSV_ABI MOCANA_freeMocana(); +int PS4_SYSV_ABI MOCANA_initMocana(); +int PS4_SYSV_ABI RSA_verifySignature(); +int PS4_SYSV_ABI sceSslCheckRecvPending(); +int PS4_SYSV_ABI sceSslClose(); +int PS4_SYSV_ABI sceSslConnect(); +int PS4_SYSV_ABI sceSslCreateSslConnection(); +int PS4_SYSV_ABI sceSslDeleteSslConnection(); +int PS4_SYSV_ABI sceSslDisableOption(); +int PS4_SYSV_ABI sceSslDisableOptionInternal(); +int PS4_SYSV_ABI sceSslDisableOptionInternalInsecure(); +int PS4_SYSV_ABI sceSslEnableOption(); +int PS4_SYSV_ABI sceSslEnableOptionInternal(); +int PS4_SYSV_ABI sceSslFreeCaCerts(); +int PS4_SYSV_ABI sceSslFreeCaList(); +int PS4_SYSV_ABI sceSslFreeSslCertName(); +int PS4_SYSV_ABI sceSslGetCaCerts(); +int PS4_SYSV_ABI sceSslGetCaList(); +int PS4_SYSV_ABI sceSslGetIssuerName(); +int PS4_SYSV_ABI sceSslGetMemoryPoolStats(); +int PS4_SYSV_ABI sceSslGetNameEntryCount(); +int PS4_SYSV_ABI sceSslGetNameEntryInfo(); +int PS4_SYSV_ABI sceSslGetNanoSSLModuleId(); +int PS4_SYSV_ABI sceSslGetNotAfter(); +int PS4_SYSV_ABI sceSslGetNotBefore(); +int PS4_SYSV_ABI sceSslGetSerialNumber(); +int PS4_SYSV_ABI sceSslGetSslError(); +int PS4_SYSV_ABI sceSslGetSubjectName(); +int PS4_SYSV_ABI sceSslInit(); +int PS4_SYSV_ABI sceSslLoadCert(); +int PS4_SYSV_ABI sceSslLoadRootCACert(); +int PS4_SYSV_ABI sceSslRecv(); +int PS4_SYSV_ABI sceSslReuseConnection(); +int PS4_SYSV_ABI sceSslSend(); +int PS4_SYSV_ABI sceSslSetMinSslVersion(); +int PS4_SYSV_ABI sceSslSetSslVersion(); +int PS4_SYSV_ABI sceSslSetVerifyCallback(); +int PS4_SYSV_ABI sceSslShowMemoryStat(); +int PS4_SYSV_ABI sceSslTerm(); +int PS4_SYSV_ABI sceSslUnloadCert(); +int PS4_SYSV_ABI SSL_acceptConnection(); +int PS4_SYSV_ABI SSL_acceptConnectionCommon(); +int PS4_SYSV_ABI SSL_assignCertificateStore(); +int PS4_SYSV_ABI SSL_ASYNC_acceptConnection(); +int PS4_SYSV_ABI SSL_ASYNC_closeConnection(); +int PS4_SYSV_ABI SSL_ASYNC_connect(); +int PS4_SYSV_ABI SSL_ASYNC_connectCommon(); +int PS4_SYSV_ABI SSL_ASYNC_getRecvBuffer(); +int PS4_SYSV_ABI SSL_ASYNC_getSendBuffer(); +int PS4_SYSV_ABI SSL_ASYNC_init(); +int PS4_SYSV_ABI SSL_ASYNC_initServer(); +int PS4_SYSV_ABI SSL_ASYNC_recvMessage(); +int PS4_SYSV_ABI SSL_ASYNC_recvMessage2(); +int PS4_SYSV_ABI SSL_ASYNC_sendMessage(); +int PS4_SYSV_ABI SSL_ASYNC_sendMessagePending(); +int PS4_SYSV_ABI SSL_ASYNC_start(); +int PS4_SYSV_ABI SSL_closeConnection(); +int PS4_SYSV_ABI SSL_connect(); +int PS4_SYSV_ABI SSL_connectWithCfgParam(); +int PS4_SYSV_ABI SSL_enableCiphers(); +int PS4_SYSV_ABI SSL_findConnectionInstance(); +int PS4_SYSV_ABI SSL_getCipherInfo(); +int PS4_SYSV_ABI SSL_getClientRandom(); +int PS4_SYSV_ABI SSL_getClientSessionInfo(); +int PS4_SYSV_ABI SSL_getCookie(); +int PS4_SYSV_ABI SSL_getNextSessionId(); +int PS4_SYSV_ABI SSL_getServerRandom(); +int PS4_SYSV_ABI SSL_getSessionCache(); +int PS4_SYSV_ABI SSL_getSessionFlags(); +int PS4_SYSV_ABI SSL_getSessionInfo(); +int PS4_SYSV_ABI SSL_getSessionStatus(); +int PS4_SYSV_ABI SSL_getSocketId(); +int PS4_SYSV_ABI SSL_getSSLTLSVersion(); +int PS4_SYSV_ABI SSL_init(); +int PS4_SYSV_ABI SSL_initiateRehandshake(); +int PS4_SYSV_ABI SSL_initServerCert(); +int PS4_SYSV_ABI SSL_ioctl(); +int PS4_SYSV_ABI SSL_isSessionSSL(); +int PS4_SYSV_ABI SSL_lockSessionCacheMutex(); +int PS4_SYSV_ABI SSL_lookupAlert(); +int PS4_SYSV_ABI SSL_negotiateConnection(); +int PS4_SYSV_ABI SSL_recv(); +int PS4_SYSV_ABI SSL_recvPending(); +int PS4_SYSV_ABI SSL_releaseTables(); +int PS4_SYSV_ABI SSL_retrieveServerNameList(); +int PS4_SYSV_ABI SSL_rngFun(); +int PS4_SYSV_ABI SSL_send(); +int PS4_SYSV_ABI SSL_sendAlert(); +int PS4_SYSV_ABI SSL_sendPending(); +int PS4_SYSV_ABI SSL_setCookie(); +int PS4_SYSV_ABI SSL_setServerCert(); +int PS4_SYSV_ABI SSL_setServerNameList(); +int PS4_SYSV_ABI SSL_setSessionFlags(); +int PS4_SYSV_ABI SSL_shutdown(); +int PS4_SYSV_ABI SSL_sslSettings(); +int PS4_SYSV_ABI SSL_validateCertParam(); +int PS4_SYSV_ABI VLONG_freeVlongQueue(); +int PS4_SYSV_ABI Func_22E76E60BC0587D7(); +int PS4_SYSV_ABI Func_28F8791A771D39C7(); + +void RegisterlibSceSsl(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Ssl \ No newline at end of file From 37813c1f59238f698f7ea12eaff85addd5486b4a Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Fri, 29 Mar 2024 23:28:06 +0200 Subject: [PATCH 02/14] clang format fix --- src/core/libraries/libscenetctl.cpp | 944 ++++++++++++++-------------- 1 file changed, 455 insertions(+), 489 deletions(-) diff --git a/src/core/libraries/libscenetctl.cpp b/src/core/libraries/libscenetctl.cpp index cdafbfc2..c8ae1fad 100644 --- a/src/core/libraries/libscenetctl.cpp +++ b/src/core/libraries/libscenetctl.cpp @@ -2,669 +2,635 @@ // SPDX-License-Identifier: GPL-2.0-or-later // Generated By moduleGenerator -#include "libscenetctl.h" #include "common/logging/log.h" #include "error_codes.h" +#include "libscenetctl.h" -namespace Libraries::NetCtl{ +namespace Libraries::NetCtl { -int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt() -{ +int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt() { LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweClearEventIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweClearEventIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweGetInfoIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweGetInfoIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetInfoV6() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetInfoV6() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetResultV6() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetResultV6() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetStateV6() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetStateV6() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlCheckCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlCheckCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlClearEventIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlClearEventIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlConnectIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlConnectIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetIfStat() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetIfStat() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetInfo() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetInfo() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetNatInfo() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetNatInfo() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetResult() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetResult() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetResultIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetResultIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetState() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetState() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetState2IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetState2IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetStateIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetStateIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlGetWifiType() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlGetWifiType() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlInit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlInit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlScanIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlScanIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlTerm() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlTerm() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI Func_D8DCB6973537A3DC() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI Func_D8DCB6973537A3DC() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApCheckCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApCheckCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApClearEvent() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApClearEvent() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApGetConnectInfo() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApGetConnectInfo() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApGetInfo() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApGetInfo() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApGetResult() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApGetResult() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApGetState() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApGetState() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApInit() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApInit() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRegisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApRegisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApStop() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApStop() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApTerm() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApTerm() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApUnregisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApUnregisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRestart() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApRestart() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRpCheckCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApRpCheckCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRpClearEvent() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApRpClearEvent() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRpGetInfo() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceNetCtlApRpGetInfo() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; } -int PS4_SYSV_ABI sceNetCtlApRpGetResult() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpGetState() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpStart() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpStartConf() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpStop() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback() -{ - LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); - return ORBIS_OK; -} - -void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver * sym) { - LIB_FUNCTION("XtClSOC1xcU", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweCheckCallbackIpcInt ); - LIB_FUNCTION("YALqoY4aeY0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweClearEventIpcInt ); - LIB_FUNCTION("ouyROWhGUbM", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweFinishInternetConnectionTestIpcInt ); - LIB_FUNCTION("G4vltQ0Vs+0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweGetInfoIpcInt ); - LIB_FUNCTION("GqETL5+INhU", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweRegisterCallbackIpcInt ); - LIB_FUNCTION("mEUt-phGd5E", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweSetInternetConnectionTestResultIpcInt ); - LIB_FUNCTION("pQLJV5SEAqk", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweStartInternetConnectionTestBandwidthTestIpcInt ); - LIB_FUNCTION("c+aYh130SV0", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweStartInternetConnectionTestIpcInt ); - LIB_FUNCTION("0lViPaTB-R8", "libSceNetBwe" , 1 , "libSceNetCtl", 1, 1 , sceNetBweUnregisterCallbackIpcInt ); - LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6 ); - LIB_FUNCTION("H5yARg37U5g", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6 ); - LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6 ); - LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6 ); - LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtlV6" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6 ); - LIB_FUNCTION("iQw3iQPhvUQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallback ); - LIB_FUNCTION("UF6H6+kjyQs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallbackForLibIpcInt ); - LIB_FUNCTION("vv6g8zoanL4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventForLibIpcInt ); - LIB_FUNCTION("8OJ86vFucfo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventIpcInt ); - LIB_FUNCTION("HCD46HVTyQg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectConfIpcInt ); - LIB_FUNCTION("ID+Gq3Ddzbg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectIpcInt ); - LIB_FUNCTION("aPpic8K75YA", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlConnectWithRetryIpcInt ); - LIB_FUNCTION("9y4IcsJdTCc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlDisableBandwidthManagementIpcInt ); - LIB_FUNCTION("qOefcpoSs0k", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlDisconnectIpcInt ); - LIB_FUNCTION("x9bSmRSE+hc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlEnableBandwidthManagementIpcInt ); - LIB_FUNCTION("eCUIlA2t5CE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetBandwidthInfoIpcInt ); - LIB_FUNCTION("2EfjPXVPk3s", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetEtherLinkMode ); - LIB_FUNCTION("teuK4QnJTGg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetIfStat ); - LIB_FUNCTION("obuxdTiwkF8", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfo ); - LIB_FUNCTION("xstcTqAhTys", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoIpcInt ); - LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6 ); - LIB_FUNCTION("arAQRFlwqaA", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetInfoV6IpcInt ); - LIB_FUNCTION("JO4yuTuMoKI", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNatInfo ); - LIB_FUNCTION("x+cnsAxKSHo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNatInfoIpcInt ); - LIB_FUNCTION("hhTsdv99azU", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetNetEvConfigInfoIpcInt ); - LIB_FUNCTION("0cBgduPRR+M", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResult ); - LIB_FUNCTION("NEtnusbZyAs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultIpcInt ); - LIB_FUNCTION("H5yARg37U5g", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6 ); - LIB_FUNCTION("vdsTa93atXY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetResultV6IpcInt ); - LIB_FUNCTION("wP0Ab2maR1Y", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoBssidForSsidListScanIpcInt ); - LIB_FUNCTION("Wn-+887Lt2s", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoBssidIpcInt ); - LIB_FUNCTION("FEdkOG1VbQo", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoByBssidIpcInt ); - LIB_FUNCTION("irV8voIAHDw", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoForSsidListScanIpcInt ); - LIB_FUNCTION("L97eAHI0xxs", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetScanInfoForSsidScanIpcInt ); - LIB_FUNCTION("uBPlr0lbuiI", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetState ); - LIB_FUNCTION("JXlI9EZVjf4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetState2IpcInt ); - LIB_FUNCTION("gvnJPMkSoAY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateIpcInt ); - LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6 ); - LIB_FUNCTION("O8Fk4w5MWss", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetStateV6IpcInt ); - LIB_FUNCTION("BXW9b3R1Nw4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlGetWifiType ); - LIB_FUNCTION("gky0+oaNM4k", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlInit ); - LIB_FUNCTION("YtAnCkTR0K4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlIsBandwidthManagementEnabledIpcInt ); - LIB_FUNCTION("UJ+Z7Q+4ck0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallback ); - LIB_FUNCTION("WRvDk2syatE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackForLibIpcInt ); - LIB_FUNCTION("rqkh2kXvLSw", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackIpcInt ); - LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6 ); - LIB_FUNCTION("ipqlpcIqRsQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackV6IpcInt ); - LIB_FUNCTION("reIsHryCDx4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlScanIpcInt ); - LIB_FUNCTION("LJYiiIS4HB0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlSetErrorNotificationEnabledIpcInt ); - LIB_FUNCTION("DjuqqqV08Nk", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlSetStunWithPaddingFlagIpcInt ); - LIB_FUNCTION("Z4wwCFiBELQ", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlTerm ); - LIB_FUNCTION("Rqm2OnZMCz0", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallback ); - LIB_FUNCTION("urWaUWkEGZg", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackForLibIpcInt ); - LIB_FUNCTION("by9cbB7JGJE", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackIpcInt ); - LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6 ); - LIB_FUNCTION("Hjxpy28aID8", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackV6IpcInt ); - LIB_FUNCTION("1HSvkN9oxO4", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnsetStunWithPaddingFlagIpcInt ); - LIB_FUNCTION("2Ny2lzU3o9w", "libSceNetCtl" , 1 , "libSceNetCtl", 1, 1 , Func_D8DCB6973537A3DC ); - LIB_FUNCTION("u5oqtlIP+Fw", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlCheckCallbackForNpToolkit ); - LIB_FUNCTION("saYB0b2ZWtI", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlClearEventForNpToolkit ); - LIB_FUNCTION("wIsKy+TfeLs", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlRegisterCallbackForNpToolkit ); - LIB_FUNCTION("2oUqKR5odGc", "libSceNetCtlForNpToolkit" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlUnregisterCallbackForNpToolkit ); - LIB_FUNCTION("19Ec7WkMFfQ", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApCheckCallback ); - LIB_FUNCTION("meFMaDpdsVI", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApClearEvent ); - LIB_FUNCTION("hfkLVdXmfnU", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetConnectInfo ); - LIB_FUNCTION("LXADzTIzM9I", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetInfo ); - LIB_FUNCTION("4jkLJc954+Q", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetResult ); - LIB_FUNCTION("AKZOzsb9whc", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApGetState ); - LIB_FUNCTION("FdN+edNRtiw", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApInit ); - LIB_FUNCTION("pmjobSVHuY0", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRegisterCallback ); - LIB_FUNCTION("r-pOyN6AhsM", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApStop ); - LIB_FUNCTION("cv5Y2efOTeg", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApTerm ); - LIB_FUNCTION("NpTcFtaQ-0E", "libSceNetCtlAp" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApUnregisterCallback ); - LIB_FUNCTION("R-4a9Yh4tG8", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppInitWpaKey ); - LIB_FUNCTION("5oLJoOVBbGU", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppInitWpaKeyForQa ); - LIB_FUNCTION("YtTwZ3pa4aQ", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppStartWithRetry ); - LIB_FUNCTION("sgWeDrEt24U", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApAppStartWithRetryPid ); - LIB_FUNCTION("amqSGH8l--s", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRestart ); - LIB_FUNCTION("DufQZgH5ISc", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpCheckCallback ); - LIB_FUNCTION("qhZbOi+2qLY", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpClearEvent ); - LIB_FUNCTION("VQl16Q+qXeY", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetInfo ); - LIB_FUNCTION("3pxwYqHzGcw", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetResult ); - LIB_FUNCTION("LEn8FGztKWc", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpGetState ); - LIB_FUNCTION("ofGsK+xoAaM", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpRegisterCallback ); - LIB_FUNCTION("mjFgpqNavHg", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStart ); - LIB_FUNCTION("HMvaHoZWsn8", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStartConf ); - LIB_FUNCTION("9Dxg7XSlr2s", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStartWithRetry ); - LIB_FUNCTION("6uvAl4RlEyk", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpStop ); - LIB_FUNCTION("8eyH37Ns8tk", "libSceNetCtlApIpcInt" , 1 , "libSceNetCtl", 1, 1 , sceNetCtlApRpUnregisterCallback ); +int PS4_SYSV_ABI sceNetCtlApRpGetResult() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpGetState() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStart() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStartConf() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpStop() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback() { + LOG_ERROR(Lib_NetCtl, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("XtClSOC1xcU", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweCheckCallbackIpcInt); + LIB_FUNCTION("YALqoY4aeY0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, sceNetBweClearEventIpcInt); + LIB_FUNCTION("ouyROWhGUbM", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweFinishInternetConnectionTestIpcInt); + LIB_FUNCTION("G4vltQ0Vs+0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, sceNetBweGetInfoIpcInt); + LIB_FUNCTION("GqETL5+INhU", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweRegisterCallbackIpcInt); + LIB_FUNCTION("mEUt-phGd5E", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweSetInternetConnectionTestResultIpcInt); + LIB_FUNCTION("pQLJV5SEAqk", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweStartInternetConnectionTestBandwidthTestIpcInt); + LIB_FUNCTION("c+aYh130SV0", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweStartInternetConnectionTestIpcInt); + LIB_FUNCTION("0lViPaTB-R8", "libSceNetBwe", 1, "libSceNetCtl", 1, 1, + sceNetBweUnregisterCallbackIpcInt); + LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6); + LIB_FUNCTION("H5yARg37U5g", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultV6); + LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6); + LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackV6); + LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtlV6", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackV6); + LIB_FUNCTION("iQw3iQPhvUQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlCheckCallback); + LIB_FUNCTION("UF6H6+kjyQs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlCheckCallbackForLibIpcInt); + LIB_FUNCTION("vv6g8zoanL4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlClearEventForLibIpcInt); + LIB_FUNCTION("8OJ86vFucfo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlClearEventIpcInt); + LIB_FUNCTION("HCD46HVTyQg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlConnectConfIpcInt); + LIB_FUNCTION("ID+Gq3Ddzbg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlConnectIpcInt); + LIB_FUNCTION("aPpic8K75YA", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlConnectWithRetryIpcInt); + LIB_FUNCTION("9y4IcsJdTCc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlDisableBandwidthManagementIpcInt); + LIB_FUNCTION("qOefcpoSs0k", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlDisconnectIpcInt); + LIB_FUNCTION("x9bSmRSE+hc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlEnableBandwidthManagementIpcInt); + LIB_FUNCTION("eCUIlA2t5CE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetBandwidthInfoIpcInt); + LIB_FUNCTION("2EfjPXVPk3s", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetEtherLinkMode); + LIB_FUNCTION("teuK4QnJTGg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetIfStat); + LIB_FUNCTION("obuxdTiwkF8", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfo); + LIB_FUNCTION("xstcTqAhTys", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoIpcInt); + LIB_FUNCTION("Jy1EO5GdlcM", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6); + LIB_FUNCTION("arAQRFlwqaA", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetInfoV6IpcInt); + LIB_FUNCTION("JO4yuTuMoKI", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetNatInfo); + LIB_FUNCTION("x+cnsAxKSHo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetNatInfoIpcInt); + LIB_FUNCTION("hhTsdv99azU", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetNetEvConfigInfoIpcInt); + LIB_FUNCTION("0cBgduPRR+M", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResult); + LIB_FUNCTION("NEtnusbZyAs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultIpcInt); + LIB_FUNCTION("H5yARg37U5g", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetResultV6); + LIB_FUNCTION("vdsTa93atXY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetResultV6IpcInt); + LIB_FUNCTION("wP0Ab2maR1Y", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetScanInfoBssidForSsidListScanIpcInt); + LIB_FUNCTION("Wn-+887Lt2s", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetScanInfoBssidIpcInt); + LIB_FUNCTION("FEdkOG1VbQo", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetScanInfoByBssidIpcInt); + LIB_FUNCTION("irV8voIAHDw", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetScanInfoForSsidListScanIpcInt); + LIB_FUNCTION("L97eAHI0xxs", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlGetScanInfoForSsidScanIpcInt); + LIB_FUNCTION("uBPlr0lbuiI", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetState); + LIB_FUNCTION("JXlI9EZVjf4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetState2IpcInt); + LIB_FUNCTION("gvnJPMkSoAY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateIpcInt); + LIB_FUNCTION("+lxqIKeU9UY", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6); + LIB_FUNCTION("O8Fk4w5MWss", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetStateV6IpcInt); + LIB_FUNCTION("BXW9b3R1Nw4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlGetWifiType); + LIB_FUNCTION("gky0+oaNM4k", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlInit); + LIB_FUNCTION("YtAnCkTR0K4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlIsBandwidthManagementEnabledIpcInt); + LIB_FUNCTION("UJ+Z7Q+4ck0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlRegisterCallback); + LIB_FUNCTION("WRvDk2syatE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackForLibIpcInt); + LIB_FUNCTION("rqkh2kXvLSw", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackIpcInt); + LIB_FUNCTION("1NE9OWdBIww", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackV6); + LIB_FUNCTION("ipqlpcIqRsQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackV6IpcInt); + LIB_FUNCTION("reIsHryCDx4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlScanIpcInt); + LIB_FUNCTION("LJYiiIS4HB0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlSetErrorNotificationEnabledIpcInt); + LIB_FUNCTION("DjuqqqV08Nk", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlSetStunWithPaddingFlagIpcInt); + LIB_FUNCTION("Z4wwCFiBELQ", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, sceNetCtlTerm); + LIB_FUNCTION("Rqm2OnZMCz0", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallback); + LIB_FUNCTION("urWaUWkEGZg", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackForLibIpcInt); + LIB_FUNCTION("by9cbB7JGJE", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackIpcInt); + LIB_FUNCTION("hIUVeUNxAwc", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackV6); + LIB_FUNCTION("Hjxpy28aID8", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackV6IpcInt); + LIB_FUNCTION("1HSvkN9oxO4", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnsetStunWithPaddingFlagIpcInt); + LIB_FUNCTION("2Ny2lzU3o9w", "libSceNetCtl", 1, "libSceNetCtl", 1, 1, Func_D8DCB6973537A3DC); + LIB_FUNCTION("u5oqtlIP+Fw", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1, + sceNetCtlCheckCallbackForNpToolkit); + LIB_FUNCTION("saYB0b2ZWtI", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1, + sceNetCtlClearEventForNpToolkit); + LIB_FUNCTION("wIsKy+TfeLs", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1, + sceNetCtlRegisterCallbackForNpToolkit); + LIB_FUNCTION("2oUqKR5odGc", "libSceNetCtlForNpToolkit", 1, "libSceNetCtl", 1, 1, + sceNetCtlUnregisterCallbackForNpToolkit); + LIB_FUNCTION("19Ec7WkMFfQ", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, + sceNetCtlApCheckCallback); + LIB_FUNCTION("meFMaDpdsVI", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApClearEvent); + LIB_FUNCTION("hfkLVdXmfnU", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, + sceNetCtlApGetConnectInfo); + LIB_FUNCTION("LXADzTIzM9I", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetInfo); + LIB_FUNCTION("4jkLJc954+Q", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetResult); + LIB_FUNCTION("AKZOzsb9whc", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApGetState); + LIB_FUNCTION("FdN+edNRtiw", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApInit); + LIB_FUNCTION("pmjobSVHuY0", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRegisterCallback); + LIB_FUNCTION("r-pOyN6AhsM", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApStop); + LIB_FUNCTION("cv5Y2efOTeg", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, sceNetCtlApTerm); + LIB_FUNCTION("NpTcFtaQ-0E", "libSceNetCtlAp", 1, "libSceNetCtl", 1, 1, + sceNetCtlApUnregisterCallback); + LIB_FUNCTION("R-4a9Yh4tG8", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApAppInitWpaKey); + LIB_FUNCTION("5oLJoOVBbGU", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApAppInitWpaKeyForQa); + LIB_FUNCTION("YtTwZ3pa4aQ", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApAppStartWithRetry); + LIB_FUNCTION("sgWeDrEt24U", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApAppStartWithRetryPid); + LIB_FUNCTION("amqSGH8l--s", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRestart); + LIB_FUNCTION("DufQZgH5ISc", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpCheckCallback); + LIB_FUNCTION("qhZbOi+2qLY", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpClearEvent); + LIB_FUNCTION("VQl16Q+qXeY", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpGetInfo); + LIB_FUNCTION("3pxwYqHzGcw", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpGetResult); + LIB_FUNCTION("LEn8FGztKWc", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpGetState); + LIB_FUNCTION("ofGsK+xoAaM", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpRegisterCallback); + LIB_FUNCTION("mjFgpqNavHg", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpStart); + LIB_FUNCTION("HMvaHoZWsn8", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpStartConf); + LIB_FUNCTION("9Dxg7XSlr2s", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpStartWithRetry); + LIB_FUNCTION("6uvAl4RlEyk", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, sceNetCtlApRpStop); + LIB_FUNCTION("8eyH37Ns8tk", "libSceNetCtlApIpcInt", 1, "libSceNetCtl", 1, 1, + sceNetCtlApRpUnregisterCallback); }; -} \ No newline at end of file +} // namespace Libraries::NetCtl \ No newline at end of file From 8e8a82a3108fd2f1159f84f36923127a7efaa4d9 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 30 Mar 2024 09:35:00 +0200 Subject: [PATCH 03/14] some dummy net functions --- src/core/libraries/libscehttp.cpp | 8 +++++--- src/core/libraries/libscehttp.h | 2 +- src/core/libraries/libscenet.cpp | 6 +++--- src/core/libraries/libscenet.h | 2 +- src/core/libraries/libscesavedata.cpp | 2 +- src/core/libraries/libscessl.cpp | 8 +++++--- src/core/libraries/libscessl.h | 2 +- 7 files changed, 17 insertions(+), 13 deletions(-) diff --git a/src/core/libraries/libscehttp.cpp b/src/core/libraries/libscehttp.cpp index 7d6888d0..ebbf2218 100644 --- a/src/core/libraries/libscehttp.cpp +++ b/src/core/libraries/libscehttp.cpp @@ -258,9 +258,11 @@ int PS4_SYSV_ABI sceHttpGetStatusCode() { return ORBIS_OK; } -int PS4_SYSV_ABI sceHttpInit() { - LOG_ERROR(Lib_Http, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize) { + LOG_ERROR(Lib_Http, "(DUMMY) called libnetMemId = {} libsslCtxId = {} poolSize = {}",libnetMemId,libsslCtxId,poolSize); + // return a value >1 + static int id = 0; + return ++id; } int PS4_SYSV_ABI sceHttpParseResponseHeader() { diff --git a/src/core/libraries/libscehttp.h b/src/core/libraries/libscehttp.h index f666b716..61da6155 100644 --- a/src/core/libraries/libscehttp.h +++ b/src/core/libraries/libscehttp.h @@ -57,7 +57,7 @@ int PS4_SYSV_ABI sceHttpGetNonblock(); int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds(); int PS4_SYSV_ABI sceHttpGetResponseContentLength(); int PS4_SYSV_ABI sceHttpGetStatusCode(); -int PS4_SYSV_ABI sceHttpInit(); +int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize); int PS4_SYSV_ABI sceHttpParseResponseHeader(); int PS4_SYSV_ABI sceHttpParseStatusLine(); int PS4_SYSV_ABI sceHttpReadData(); diff --git a/src/core/libraries/libscenet.cpp b/src/core/libraries/libscenet.cpp index da5c8550..3a98e17c 100644 --- a/src/core/libraries/libscenet.cpp +++ b/src/core/libraries/libscenet.cpp @@ -744,7 +744,7 @@ int PS4_SYSV_ABI sceNetInfoDumpStop() { } int PS4_SYSV_ABI sceNetInit() { - LOG_ERROR(Lib_Net, "(STUBBED) called"); + LOG_ERROR(Lib_Net, "(DUMMY) called"); return ORBIS_OK; } @@ -788,8 +788,8 @@ int PS4_SYSV_ABI sceNetNtohs() { return ORBIS_OK; } -int PS4_SYSV_ABI sceNetPoolCreate() { - LOG_ERROR(Lib_Net, "(STUBBED) called"); +int PS4_SYSV_ABI sceNetPoolCreate(const char* name, int size, int flags) { + LOG_ERROR(Lib_Net, "(DUMMY) name = {} size = {} flags = {} ", std::string(name), size, flags); return ORBIS_OK; } diff --git a/src/core/libraries/libscenet.h b/src/core/libraries/libscenet.h index b71edb49..626cd345 100644 --- a/src/core/libraries/libscenet.h +++ b/src/core/libraries/libscenet.h @@ -163,7 +163,7 @@ int PS4_SYSV_ABI sceNetMemoryFree(); int PS4_SYSV_ABI sceNetNtohl(); int PS4_SYSV_ABI sceNetNtohll(); int PS4_SYSV_ABI sceNetNtohs(); -int PS4_SYSV_ABI sceNetPoolCreate(); +int PS4_SYSV_ABI sceNetPoolCreate(const char* name, int size, int flags); int PS4_SYSV_ABI sceNetPoolDestroy(); int PS4_SYSV_ABI sceNetPppoeStart(); int PS4_SYSV_ABI sceNetPppoeStop(); diff --git a/src/core/libraries/libscesavedata.cpp b/src/core/libraries/libscesavedata.cpp index 57ba7b4d..e3ae6e35 100644 --- a/src/core/libraries/libscesavedata.cpp +++ b/src/core/libraries/libscesavedata.cpp @@ -299,7 +299,7 @@ int PS4_SYSV_ABI sceSaveDataInitialize2() { } int PS4_SYSV_ABI sceSaveDataInitialize3() { - LOG_ERROR(Lib_SaveData, "(STUBBED) called"); + LOG_ERROR(Lib_SaveData, "(DUMMY) called"); return ORBIS_OK; } diff --git a/src/core/libraries/libscessl.cpp b/src/core/libraries/libscessl.cpp index ae1e607e..2d95dd50 100644 --- a/src/core/libraries/libscessl.cpp +++ b/src/core/libraries/libscessl.cpp @@ -693,9 +693,11 @@ int PS4_SYSV_ABI sceSslGetSubjectName() { return ORBIS_OK; } -int PS4_SYSV_ABI sceSslInit() { - LOG_ERROR(Lib_Ssl, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceSslInit(std::size_t poolSize) { + LOG_ERROR(Lib_Ssl, "(DUMMY) called poolSize = {}",poolSize); + //return a value >1 + static int id = 0; + return ++id; } int PS4_SYSV_ABI sceSslLoadCert() { diff --git a/src/core/libraries/libscessl.h b/src/core/libraries/libscessl.h index 06eefd21..8a4d0915 100644 --- a/src/core/libraries/libscessl.h +++ b/src/core/libraries/libscessl.h @@ -144,7 +144,7 @@ int PS4_SYSV_ABI sceSslGetNotBefore(); int PS4_SYSV_ABI sceSslGetSerialNumber(); int PS4_SYSV_ABI sceSslGetSslError(); int PS4_SYSV_ABI sceSslGetSubjectName(); -int PS4_SYSV_ABI sceSslInit(); +int PS4_SYSV_ABI sceSslInit(std::size_t poolSize); int PS4_SYSV_ABI sceSslLoadCert(); int PS4_SYSV_ABI sceSslLoadRootCACert(); int PS4_SYSV_ABI sceSslRecv(); From 94cd3be814cdcd00fc43473c8e42365c086e1293 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 30 Mar 2024 15:34:01 +0200 Subject: [PATCH 04/14] dummy sysmodule module --- CMakeLists.txt | 2 + src/common/logging/filter.cpp | 1 + src/common/logging/types.h | 5 +- src/core/hle/libraries/libs.cpp | 2 + src/core/libraries/libscessl.cpp | 2 +- src/core/libraries/libscesysmodule.cpp | 134 ++++++++++++++++++++ src/core/libraries/libscesysmodule.h | 164 +++++++++++++++++++++++++ 7 files changed, 307 insertions(+), 3 deletions(-) create mode 100644 src/core/libraries/libscesysmodule.cpp create mode 100644 src/core/libraries/libscesysmodule.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 63a16126..d18fa0c4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -114,6 +114,8 @@ set(LIBRARIES src/core/libraries/library_common.h src/core/libraries/libscesavedata.h src/core/libraries/libscessl.cpp src/core/libraries/libscessl.h + src/core/libraries/libscesysmodule.cpp + src/core/libraries/libscesysmodule.h src/core/libraries/libscesystemservice.cpp src/core/libraries/libscesystemservice.h src/core/libraries/libsceuserservice.cpp diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp index 0ee022de..0714362c 100644 --- a/src/common/logging/filter.cpp +++ b/src/common/logging/filter.cpp @@ -93,6 +93,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) { SUB(Lib, SaveData) \ SUB(Lib, Http) \ SUB(Lib, Ssl) \ + SUB(Lib, SysModule) \ CLS(Frontend) \ CLS(Render) \ SUB(Render, Vulkan) \ diff --git a/src/common/logging/types.h b/src/common/logging/types.h index 9fa50412..0d4fb575 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -58,8 +58,9 @@ enum class Class : u8 { Lib_Net, ///< The LibSceNet implementation. Lib_NetCtl, ///< The LibSecNetCtl implementation. Lib_SaveData, ///< The LibSceSaveData implementation. - Lib_Ssl, ///< The LibSsl implementation. - Lib_Http, ///< The LibHttp implementation. + Lib_Ssl, ///< The LibSceSsl implementation. + Lib_Http, ///< The LibSceHttp implementation. + Lib_SysModule, ///< The LibSceSysModule implementation Frontend, ///< Emulator UI Render, ///< Video Core Render_Vulkan, ///< Vulkan backend diff --git a/src/core/hle/libraries/libs.cpp b/src/core/hle/libraries/libs.cpp index 2c8aedc8..a58c3e92 100644 --- a/src/core/hle/libraries/libs.cpp +++ b/src/core/hle/libraries/libs.cpp @@ -18,6 +18,7 @@ #include "src/core/libraries/libscessl.h" #include "src/core/libraries/libscesystemservice.h" #include "src/core/libraries/libsceuserservice.h" +#include "src/core/libraries/libscesysmodule.h" namespace OldLibraries { @@ -41,6 +42,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) { Libraries::NetCtl::RegisterlibSceNetCtl(sym); Libraries::SaveData::RegisterlibSceSaveData(sym); Libraries::Ssl::RegisterlibSceSsl(sym); + Libraries::SysModule::RegisterlibSceSysmodule(sym); } } // namespace OldLibraries diff --git a/src/core/libraries/libscessl.cpp b/src/core/libraries/libscessl.cpp index 2d95dd50..3a3a0ff2 100644 --- a/src/core/libraries/libscessl.cpp +++ b/src/core/libraries/libscessl.cpp @@ -694,7 +694,7 @@ int PS4_SYSV_ABI sceSslGetSubjectName() { } int PS4_SYSV_ABI sceSslInit(std::size_t poolSize) { - LOG_ERROR(Lib_Ssl, "(DUMMY) called poolSize = {}",poolSize); + LOG_ERROR(Lib_Ssl, "(DUMMY) called poolSize = {}", poolSize); //return a value >1 static int id = 0; return ++id; diff --git a/src/core/libraries/libscesysmodule.cpp b/src/core/libraries/libscesysmodule.cpp new file mode 100644 index 00000000..d47ff136 --- /dev/null +++ b/src/core/libraries/libscesysmodule.cpp @@ -0,0 +1,134 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include +#include "common/logging/log.h" +#include "error_codes.h" +#include "libscesysmodule.h" + +namespace Libraries::SysModule { + +int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleIsLoaded() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +template <> +struct magic_enum::customize::enum_range { + static constexpr int min = 0; + static constexpr int max = 300; +}; + +int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id) { + auto color_name = magic_enum::enum_name(id); + LOG_ERROR(Lib_SysModule, "(DUMMY) called module = {}", magic_enum::enum_name(id)); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleLoadModuleInternalWithArg() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleMapLibcForLibkernel() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmodulePreloadModuleForLibkernel() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleUnloadModule() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleUnloadModuleByNameInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternal() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternalWithArg() { + LOG_ERROR(Lib_SysModule, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceSysmodule(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("D8cuU4d72xM", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleGetModuleHandleInternal); + LIB_FUNCTION("4fU5yvOkVG4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleGetModuleInfoForUnwind); + LIB_FUNCTION("ctfO7dQ7geg", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleIsCalledFromSysModule); + LIB_FUNCTION("no6T3EfiS3E", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleIsCameraPreloaded); + LIB_FUNCTION("fMP5NHUOaMk", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleIsLoaded); + LIB_FUNCTION("ynFKQ5bfGks", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleIsLoadedInternal); + LIB_FUNCTION("g8cM39EUZ6o", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleLoadModule); + LIB_FUNCTION("CU8m+Qs+HN4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleLoadModuleByNameInternal); + LIB_FUNCTION("39iV5E1HoCk", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleLoadModuleInternal); + LIB_FUNCTION("hHrGoGoNf+s", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleLoadModuleInternalWithArg); + LIB_FUNCTION("lZ6RvVl0vo0", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleMapLibcForLibkernel); + LIB_FUNCTION("DOO+zuW1lrE", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmodulePreloadModuleForLibkernel); + LIB_FUNCTION("eR2bZFAAU0Q", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleUnloadModule); + LIB_FUNCTION("vpTHmA6Knvg", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleUnloadModuleByNameInternal); + LIB_FUNCTION("vXZhrtJxkGc", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleUnloadModuleInternal); + LIB_FUNCTION("aKa6YfBKZs4", "libSceSysmodule", 1, "libSceSysmodule", 1, 1, + sceSysmoduleUnloadModuleInternalWithArg); +}; + +} // namespace Libraries::SysModule \ No newline at end of file diff --git a/src/core/libraries/libscesysmodule.h b/src/core/libraries/libscesysmodule.h new file mode 100644 index 00000000..7f58fe7b --- /dev/null +++ b/src/core/libraries/libscesysmodule.h @@ -0,0 +1,164 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::SysModule { + +enum class OrbisSysModule : u16 { + ORBIS_SYSMODULE_INVALID = 0x0000, + ORBIS_SYSMODULE_FIBER = 0x0006, // libSceFiber.sprx + ORBIS_SYSMODULE_ULT = 0x0007, // libSceUlt.sprx + ORBIS_SYSMODULE_NGS2 = 0x000B, // libSceNgs2.sprx + ORBIS_SYSMODULE_XML = 0x0017, // libSceXml.sprx + ORBIS_SYSMODULE_NP_UTILITY = 0x0019, // libSceNpUtility.sprx + ORBIS_SYSMODULE_VOICE = 0x001A, // libSceVoice.sprx + ORBIS_SYSMODULE_VOICEQOS = 0x001B, // libSceVoiceQos.sprx + ORBIS_SYSMODULE_NP_MATCHING2 = 0x001C, // libSceNpMatching2.sprx + ORBIS_SYSMODULE_NP_SCORE_RANKING = 0x001E, // libSceNpScoreRanking.sprx + ORBIS_SYSMODULE_RUDP = 0x0021, // libSceRudp.sprx + ORBIS_SYSMODULE_NP_TUS = 0x002C, // libSceNpTus.sprx + ORBIS_SYSMODULE_FACE = 0x0038, + ORBIS_SYSMODULE_SMART = 0x0039, + ORBIS_SYSMODULE_JSON = 0x0080, + ORBIS_SYSMODULE_GAME_LIVE_STREAMING = 0x0081, // libSceGameLiveStreaming.sprx + ORBIS_SYSMODULE_COMPANION_UTIL = 0x0082, // libSceCompanionUtil.sprx + ORBIS_SYSMODULE_PLAYGO = 0x0083, // libScePlayGo.sprx + ORBIS_SYSMODULE_FONT = 0x0084, // libSceFont.sprx + ORBIS_SYSMODULE_VIDEO_RECORDING = 0x0085, // libSceVideoRecording.sprx + ORBIS_SYSMODULE_S3DCONVERSION = 0x0086, + ORBIS_SYSMODULE_AUDIODEC = 0x0088, // libSceAudiodec.sprx + ORBIS_SYSMODULE_JPEG_DEC = 0x008A, // libSceJpegDec.sprx + ORBIS_SYSMODULE_JPEG_ENC = 0x008B, // libSceJpegEnc.sprx + ORBIS_SYSMODULE_PNG_DEC = 0x008C, // libScePngDec.sprx + ORBIS_SYSMODULE_PNG_ENC = 0x008D, // libScePngEnc.sprx + ORBIS_SYSMODULE_VIDEODEC = 0x008E, // libSceVideodec.sprx + ORBIS_SYSMODULE_MOVE = 0x008F, // libSceMove.sprx + ORBIS_SYSMODULE_PAD_TRACKER = 0x0091, // libScePadTracker.sprx + ORBIS_SYSMODULE_DEPTH = 0x0092, // libSceDepth.sprx + ORBIS_SYSMODULE_HAND = 0x0093, + ORBIS_SYSMODULE_LIBIME = 0x0095, // libSceIme.sprx + ORBIS_SYSMODULE_IME_DIALOG = 0x0096, // libSceImeDialog.sprx + ORBIS_SYSMODULE_NP_PARTY = 0x0097, // libSceNpParty.sprx + ORBIS_SYSMODULE_FONT_FT = 0x0098, // libSceFontFt.sprx + ORBIS_SYSMODULE_FREETYPE_OT = 0x0099, // libSceFreeTypeOt.sprx + ORBIS_SYSMODULE_FREETYPE_OL = 0x009A, // libSceFreeTypeOl.sprx + ORBIS_SYSMODULE_FREETYPE_OPT_OL = 0x009B, // libSceFreeTypeOptOl.sprx + ORBIS_SYSMODULE_SCREEN_SHOT = 0x009C, // libSceScreenShot.sprx + ORBIS_SYSMODULE_NP_AUTH = 0x009D, // libSceNpAuth.sprx + ORBIS_SYSMODULE_SULPHA = 0x009F, + ORBIS_SYSMODULE_SAVE_DATA_DIALOG = 0x00A0, // libSceSaveDataDialog.sprx + ORBIS_SYSMODULE_INVITATION_DIALOG = 0x00A2, // libSceInvitationDialog.sprx + ORBIS_SYSMODULE_DEBUG_KEYBOARD = 0x00A3, + ORBIS_SYSMODULE_MESSAGE_DIALOG = 0x00A4, // libSceMsgDialog.sprx + ORBIS_SYSMODULE_AV_PLAYER = 0x00A5, // libSceAvPlayer.sprx + ORBIS_SYSMODULE_CONTENT_EXPORT = 0x00A6, // libSceContentExport.sprx + ORBIS_SYSMODULE_AUDIO_3D = 0x00A7, // libSceAudio3d.sprx + ORBIS_SYSMODULE_NP_COMMERCE = 0x00A8, // libSceNpCommerce.sprx + ORBIS_SYSMODULE_MOUSE = 0x00A9, // libSceMouse.sprx + ORBIS_SYSMODULE_COMPANION_HTTPD = 0x00AA, // libSceCompanionHttpd.sprx + ORBIS_SYSMODULE_WEB_BROWSER_DIALOG = 0x00AB, // libSceWebBrowserDialog.sprx + ORBIS_SYSMODULE_ERROR_DIALOG = 0x00AC, // libSceErrorDialog.sprx + ORBIS_SYSMODULE_NP_TROPHY = 0x00AD, // libSceNpTrophy.sprx + ORBIS_SYSMODULE_VIDEO_CORE_IF = 0x00AE, // libSceVideoCoreInterface.sprx + ORBIS_SYSMODULE_VIDEO_CORE_SERVER_IF = 0x00AF, // libSceVideoCoreServerInterface.sprx + ORBIS_SYSMODULE_NP_SNS_FACEBOOK = 0x00B0, // libSceNpSnsFacebookDialog.sprx + ORBIS_SYSMODULE_MOVE_TRACKER = 0x00B1, // libSceMoveTracker.sprx + ORBIS_SYSMODULE_NP_PROFILE_DIALOG = 0x00B2, // libSceNpProfileDialog.sprx + ORBIS_SYSMODULE_NP_FRIEND_LIST_DIALOG = 0x00B3, // libSceNpFriendListDialog.sprx + ORBIS_SYSMODULE_APP_CONTENT = 0x00B4, // libSceAppContent.sprx + ORBIS_SYSMODULE_NP_SIGNALING = 0x00B5, // libSceNpSignaling.sprx + ORBIS_SYSMODULE_REMOTE_PLAY = 0x00B6, // libSceRemoteplay.sprx + ORBIS_SYSMODULE_USBD = 0x00B7, // libSceUsbd.sprx + ORBIS_SYSMODULE_GAME_CUSTOM_DATA_DIALOG = 0x00B8, // libSceGameCustomDataDialog.sprx + ORBIS_SYSMODULE_NP_EULA_DIALOG = 0x00B9, // libSceNpEulaDialog.sprx + ORBIS_SYSMODULE_RANDOM = 0x00BA, // libSceRandom.sprx + ORBIS_SYSMODULE_RESERVED2 = 0x00BB, + ORBIS_SYSMODULE_M4AAC_ENC = 0x00BC, // libSceM4aacEnc.sprx + ORBIS_SYSMODULE_AUDIODEC_CPU = 0x00BD, // libSceAudiodecCpu.sprx + ORBIS_SYSMODULE_AUDIODEC_CPU_DDP = 0x00BE, // libSceAudiodecCpuDdp.sprx + ORBIS_SYSMODULE_AUDIODEC_CPU_M4AAC = 0x00C0, // libSceAudiodecCpuM4aac.sprx + ORBIS_SYSMODULE_BEMP2_SYS = 0x00C1, // libSceBemp2sys.sprx + ORBIS_SYSMODULE_BEISOBMF = 0x00C2, // libSceBeisobmf.sprx + ORBIS_SYSMODULE_PLAY_READY = 0x00C3, // libScePlayReady.sprx + ORBIS_SYSMODULE_VIDEO_NATIVE_EXT_ESSENTIAL = 0x00C4, // libSceVideoNativeExtEssential.sprx + ORBIS_SYSMODULE_ZLIB = 0x00C5, // libSceZlib.sprx + ORBIS_SYSMODULE_DTCP_IP = 0x00C6, // libSceDtcpIp.sprx + ORBIS_SYSMODULE_CONTENT_SEARCH = 0x00C7, // libSceContentSearch.sprx + ORBIS_SYSMODULE_SHARE_UTILITY = 0x00C8, // libSceShareUtility.sprx + ORBIS_SYSMODULE_AUDIODEC_CPU_DTS_HD_LBR = 0x00C9, // libSceAudiodecCpuDtsHdLbr.sprx + ORBIS_SYSMODULE_DECI4H = 0x00CA, + ORBIS_SYSMODULE_HEAD_TRACKER = 0x00CB, + ORBIS_SYSMODULE_GAME_UPDATE = 0x00CC, // libSceGameUpdate.sprx + ORBIS_SYSMODULE_AUTO_MOUNTER_CLIENT = 0x00CD, // libSceAutoMounterClient.sprx + ORBIS_SYSMODULE_SYSTEM_GESTURE = 0x00CE, // libSceSystemGesture.sprx + ORBIS_SYSMODULE_VIDEODEC2 = 0x00CF, + ORBIS_SYSMODULE_VDECWRAP = 0x00D0, // libSceVdecwrap.sprx + ORBIS_SYSMODULE_AT9_ENC = 0x00D1, // libSceAt9Enc.sprx + ORBIS_SYSMODULE_CONVERT_KEYCODE = 0x00D2, // libSceConvertKeycode.sprx + ORBIS_SYSMODULE_SHARE_PLAY = 0x00D3, // libSceSharePlay.sprx + ORBIS_SYSMODULE_HMD = 0x00D4, // libSceHmd.sprx + ORBIS_SYSMODULE_USB_STORAGE = 0x00D5, // libSceUsbStorage.sprx + ORBIS_SYSMODULE_USB_STORAGE_DIALOG = 0x00D6, // libSceUsbStorageDialog.sprx + ORBIS_SYSMODULE_DISC_MAP = 0x00D7, // libSceDiscMap.sprx + ORBIS_SYSMODULE_FACE_TRACKER = 0x00D8, + ORBIS_SYSMODULE_HAND_TRACKER = 0x00D9, + ORBIS_SYSMODULE_NP_SNS_YOUTUBE_DIALOG = 0x00DA, // libSceNpSnsYouTubeDialog.sprx + ORBIS_SYSMODULE_PROFILE_CACHE_EXTERNAL = 0x00DC, // libSceProfileCacheExternal.sprx + ORBIS_SYSMODULE_MUSIC_PLAYER_SERVICE = 0x00DD, // libSceMusicPlayerService.sprx + ORBIS_SYSMODULE_SP_SYS_CALL_WRAPPER = 0x00DE, // libSceSpSysCallWrapper.sprx + ORBIS_SYSMODULE_PS2_EMU_MENU_DIALOG = 0x00DF, // libScePs2EmuMenuDialog.sprx + ORBIS_SYSMODULE_NP_SNS_DIALYMOTION_DIALOG = 0x00E0, // libSceNpSnsDailyMotionDialog.sprx + ORBIS_SYSMODULE_AUDIODEC_CPU_HEVAG = 0x00E1, // libSceAudiodecCpuHevag.sprx + ORBIS_SYSMODULE_LOGIN_DIALOG = 0x00E2, // libSceLoginDialog.sprx + ORBIS_SYSMODULE_LOGIN_SERVICE = 0x00E3, // libSceLoginService.sprx + ORBIS_SYSMODULE_SIGNIN_DIALOG = 0x00E4, // libSceSigninDialog.sprx + ORBIS_SYSMODULE_VDECSW = 0x00E5, // libSceVdecsw.sprx + ORBIS_SYSMODULE_CUSTOM_MUSIC_CORE = 0x00E6, // libSceCustomMusicCore.sprx + ORBIS_SYSMODULE_JSON2 = 0x00E7, // libSceJson2.sprx + ORBIS_SYSMODULE_AUDIO_LATENCY_ESTIMATION = 0x00E8, + ORBIS_SYSMODULE_WK_FONT_CONFIG = 0x00E9, // libSceWkFontConfig.sprx + ORBIS_SYSMODULE_RESERVED27 = 0x00EA, + ORBIS_SYSMODULE_HMD_SETUP_DIALOG = 0x00EB, // libSceHmdSetupDialog.sprx + ORBIS_SYSMODULE_RESERVED28 = 0x00EC, + ORBIS_SYSMODULE_VR_TRACKER = 0x00ED, // libSceVrTracker.sprx + ORBIS_SYSMODULE_CONTENT_DELETE = 0x00EE, // libSceContentDelete.sprx + ORBIS_SYSMODULE_IME_BACKEND = 0x00EF, // libSceImeBackend.sprx + ORBIS_SYSMODULE_NET_CTL_AP_DIALOG = 0x00F0, // libSceNetCtlApDialog.sprx + ORBIS_SYSMODULE_PLAYGO_DIALOG = 0x00F1, // libScePlayGoDialog.sprx + ORBIS_SYSMODULE_SOCIAL_SCREEN = 0x00F2, // libSceSocialScreen.sprx + ORBIS_SYSMODULE_EDIT_MP4 = 0x00F3, // libSceEditMp4.sprx + ORBIS_SYSMODULE_PSM_KIT_SYSTEM = 0x00F5, // libScePsmKitSystem.sprx + ORBIS_SYSMODULE_TEXT_TO_SPEECH = 0x00F6, // libSceTextToSpeech.sprx + ORBIS_SYSMODULE_NP_TOOLKIT = 0x00F7, + ORBIS_SYSMODULE_CUSTOM_MUSIC_SERVICE = 0x00F8, // libSceCustomMusicService.sprx + ORBIS_SYSMODULE_CL_SYS_CALL_WRAPPER = 0x00F9, // libSceClSysCallWrapper.sprx + ORBIS_SYSMODULE_SYSTEM_LOGGER = 0x00FA, // libSceSystemLogger.sprx + ORBIS_SYSMODULE_BLUETOOTH_HID = 0x00FB, // libSceBluetoothHid.sprx + ORBIS_SYSMODULE_VIDEO_DECODER_ARBITRATION = 0x00FC, // libSceVideoDecoderArbitration.sprx + ORBIS_SYSMODULE_VR_SERVICE_DIALOG = 0x00FD, // libSceVrServiceDialog.sprx + ORBIS_SYSMODULE_JOB_MANAGER = 0x00FE, + ORBIS_SYSMODULE_KEYBOARD = 0x0106, +}; + +int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal(); +int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind(); +int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule(); +int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded(); +int PS4_SYSV_ABI sceSysmoduleIsLoaded(); +int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal(); +int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id); +int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal(); +int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal(); +int PS4_SYSV_ABI sceSysmoduleLoadModuleInternalWithArg(); +int PS4_SYSV_ABI sceSysmoduleMapLibcForLibkernel(); +int PS4_SYSV_ABI sceSysmodulePreloadModuleForLibkernel(); +int PS4_SYSV_ABI sceSysmoduleUnloadModule(); +int PS4_SYSV_ABI sceSysmoduleUnloadModuleByNameInternal(); +int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternal(); +int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternalWithArg(); + +void RegisterlibSceSysmodule(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::SysModule \ No newline at end of file From 5373d7367db8439aea48509a2d2ae966fdebc2af Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 30 Mar 2024 15:39:21 +0200 Subject: [PATCH 05/14] clang format fix --- src/core/libraries/libscehttp.cpp | 3 ++- src/core/libraries/libscessl.cpp | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/core/libraries/libscehttp.cpp b/src/core/libraries/libscehttp.cpp index ebbf2218..b3109f7c 100644 --- a/src/core/libraries/libscehttp.cpp +++ b/src/core/libraries/libscehttp.cpp @@ -259,7 +259,8 @@ int PS4_SYSV_ABI sceHttpGetStatusCode() { } int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize) { - LOG_ERROR(Lib_Http, "(DUMMY) called libnetMemId = {} libsslCtxId = {} poolSize = {}",libnetMemId,libsslCtxId,poolSize); + LOG_ERROR(Lib_Http, "(DUMMY) called libnetMemId = {} libsslCtxId = {} poolSize = {}", + libnetMemId, libsslCtxId, poolSize); // return a value >1 static int id = 0; return ++id; diff --git a/src/core/libraries/libscessl.cpp b/src/core/libraries/libscessl.cpp index 3a3a0ff2..650448dc 100644 --- a/src/core/libraries/libscessl.cpp +++ b/src/core/libraries/libscessl.cpp @@ -695,7 +695,7 @@ int PS4_SYSV_ABI sceSslGetSubjectName() { int PS4_SYSV_ABI sceSslInit(std::size_t poolSize) { LOG_ERROR(Lib_Ssl, "(DUMMY) called poolSize = {}", poolSize); - //return a value >1 + // return a value >1 static int id = 0; return ++id; } From 30946e21dde517fed290f9cf2111d3e3d8dea5fe Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 30 Mar 2024 15:41:12 +0200 Subject: [PATCH 06/14] more clang fixes --- src/common/logging/types.h | 2 +- src/core/hle/libraries/libs.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/common/logging/types.h b/src/common/logging/types.h index 0d4fb575..1d848d74 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -60,7 +60,7 @@ enum class Class : u8 { Lib_SaveData, ///< The LibSceSaveData implementation. Lib_Ssl, ///< The LibSceSsl implementation. Lib_Http, ///< The LibSceHttp implementation. - Lib_SysModule, ///< The LibSceSysModule implementation + Lib_SysModule, ///< The LibSceSysModule implementation Frontend, ///< Emulator UI Render, ///< Video Core Render_Vulkan, ///< Vulkan backend diff --git a/src/core/hle/libraries/libs.cpp b/src/core/hle/libraries/libs.cpp index a58c3e92..6ffc57fb 100644 --- a/src/core/hle/libraries/libs.cpp +++ b/src/core/hle/libraries/libs.cpp @@ -16,9 +16,9 @@ #include "src/core/libraries/libscenetctl.h" #include "src/core/libraries/libscesavedata.h" #include "src/core/libraries/libscessl.h" +#include "src/core/libraries/libscesysmodule.h" #include "src/core/libraries/libscesystemservice.h" #include "src/core/libraries/libsceuserservice.h" -#include "src/core/libraries/libscesysmodule.h" namespace OldLibraries { From ad7e750fa712e3c0a82c947f3f385658d9efd9fb Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sat, 30 Mar 2024 22:19:42 +0200 Subject: [PATCH 07/14] scePthreadAttrDestroy,scePthreadAttrGetaffinity added --- .../libraries/libkernel/thread_management.cpp | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 771391d5..1e7598f9 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -57,6 +57,19 @@ int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr) { } } +int PS4_SYSV_ABI scePthreadAttrDestroy(ScePthreadAttr* attr) { + + int result = pthread_attr_destroy(&(*attr)->pth_attr); + + delete *attr; + *attr = nullptr; + + if (result == 0) { + return SCE_OK; + } + return SCE_KERNEL_ERROR_EINVAL; +} + int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate) { if (attr == nullptr || *attr == nullptr) { return SCE_KERNEL_ERROR_EINVAL; @@ -157,6 +170,16 @@ int PS4_SYSV_ABI scePthreadAttrSetaffinity(ScePthreadAttr* pattr, return SCE_OK; } +int PS4_SYSV_ABI scePthreadAttrGetaffinity(const ScePthreadAttr* pattr, + /* SceKernelCpumask*/ u64* mask) { + if (pattr == nullptr || *pattr == nullptr) { + return SCE_KERNEL_ERROR_EINVAL; + } + + *mask = (*pattr)->affinity; + + return SCE_OK; +} int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask) { LOG_INFO(Kernel_Pthread, "called"); @@ -479,8 +502,12 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("eXbUSpEaTsA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetinheritsched); LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam); LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit); + LIB_FUNCTION("62KCwEMmzcM", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrDestroy); + LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf); LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity); + LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity); + LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity); LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate); // mutex calls From 8fa5874fb113f20902968a0055cdb25f145ebc94 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 11:30:43 +0300 Subject: [PATCH 08/14] dummy libkernel module --- CMakeLists.txt | 2 + .../libraries/libkernel/thread_management.cpp | 4 +- src/core/libraries/libkernel.cpp | 6762 +++++++++++++++++ src/core/libraries/libkernel.h | 1061 +++ 4 files changed, 7827 insertions(+), 2 deletions(-) create mode 100644 src/core/libraries/libkernel.cpp create mode 100644 src/core/libraries/libkernel.h diff --git a/CMakeLists.txt b/CMakeLists.txt index d18fa0c4..6f8003e0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -98,6 +98,8 @@ set(AUDIO_CORE src/audio_core/sdl_audio.cpp ) set(LIBRARIES src/core/libraries/library_common.h src/core/libraries/error_codes.h + src/core/libraries/libkernel.cpp + src/core/libraries/libkernel.h src/core/libraries/libscecommondialog.cpp src/core/libraries/libscecommondialog.h src/core/libraries/libscegnmdriver.cpp diff --git a/src/core/hle/libraries/libkernel/thread_management.cpp b/src/core/hle/libraries/libkernel/thread_management.cpp index 1e7598f9..850e64a8 100644 --- a/src/core/hle/libraries/libkernel/thread_management.cpp +++ b/src/core/hle/libraries/libkernel/thread_management.cpp @@ -503,11 +503,11 @@ void pthreadSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam); LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit); LIB_FUNCTION("62KCwEMmzcM", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrDestroy); - + LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf); LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity); LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity); - + LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity); LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate); // mutex calls diff --git a/src/core/libraries/libkernel.cpp b/src/core/libraries/libkernel.cpp new file mode 100644 index 00000000..718f784a --- /dev/null +++ b/src/core/libraries/libkernel.cpp @@ -0,0 +1,6762 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libkernel.h" + +namespace Libraries::Kernel { + +int PS4_SYSV_ABI __elf_phdr_match_addr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __error() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __freeze() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __inet_ntop() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __inet_pton() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __progname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __pthread_cleanup_pop_imp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __pthread_cleanup_push_imp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __pthread_cxa_finalize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sceKernelGetGPI() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __stack_chk_fail() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __stack_chk_guard() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_debug_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dl_get_info() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dl_get_list() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dl_get_metadata() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dynlib_get_info_for_libdbg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dynlib_get_info2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dynlib_get_list_for_libdbg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dynlib_get_list2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_dynlib_load_prx() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_get_proc_type_info() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_is_development_mode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_kqueueex() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_namedobj_create() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_namedobj_delete() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_netabort() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_netcontrol() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_netgetiflist() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_netgetsockinfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_disable() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_enable() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_get_ctr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_get_hw() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_set_ctl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_set_ctr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_opmc_set_hw() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_osem_close() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_osem_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_randomized_path() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_rdup() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_regmgr_call() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_set_uevt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_socketclose() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_socketex() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_test_debug_rwmem() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __sys_workaround8849() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __tls_get_addr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI __Ux86_64_setcontext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _accept() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _bind() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _close() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _connect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _dup2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _execve() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _execvpe() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _exit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _fcntl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _fpathconf() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _fstat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _fstatfs() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _getdirentries() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _getpeername() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _getsockname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _getsockopt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _ioctl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _is_signal_return() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _listen() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _nanosleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _openat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _read() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _readv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _recvfrom() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _recvmsg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelRtldSetApplicationHeapAPI() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelRtldThreadAtexitDecrement() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelRtldThreadAtexitIncrement() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelSetThreadAtexitCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelSetThreadAtexitReport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sceKernelSetThreadDtors() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sendmsg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sendto() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _setsockopt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sigaction() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sigintr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sigprocmask() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _sigsuspend() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _umtx_op() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _wait4() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _write() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI _writev() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI accept() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI access() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI amd64_set_fsbase() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI bind() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI blockpool_batch() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI blockpool_map() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI blockpool_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI blockpool_unmap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI chdir() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI chflags() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI chmod() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI clock_getres() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI clock_gettime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI clock_settime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI close() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI connect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI cpuset_getaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI cpuset_getid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI cpuset_setaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI creat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dlclose() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dlerror() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dlopen() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dlsym() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dup() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dup2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI dynlib_get_obj_member() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ps4_environ() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ps4_errno() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI execv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI execve() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI execvp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fchflags() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fchmod() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fcntl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fdatasync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI flock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fstat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI fsync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ftruncate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI futimes() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_authinfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_module_info_list() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_page_table_stats() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_sdk_compiled_version() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_self_auth_info() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI get_vm_map_timestamp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getargc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getargv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getcontext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getdents() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getdirentries() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getdtablesize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getegid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI geteuid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getgid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getgroups() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getitimer() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getlogin() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getlogin_r() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getpagesize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getpeername() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getpid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getppid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getpriority() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getrlimit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getrusage() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getsid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getsockname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getsockopt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI gettimeofday() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI getuid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI htonl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI htons() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI inet_ntop() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI inet_pton() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ioctl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ipmimgr_call() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI is_in_sandbox() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI issetugid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI kevent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI kill() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI kqueue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_close() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_getvalue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_post() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_timedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_trywait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_unlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ksem_wait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ktimer_create() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ktimer_delete() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ktimer_getoverrun() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ktimer_gettime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ktimer_settime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI listen() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI lseek() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI lstat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI madvise() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mdbg_service() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mincore() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mkdir() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mlockall() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mmap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI mprotect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI msync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI munlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI munlockall() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI munmap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI nanosleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ntohl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI ntohs() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pause() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI physhm_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI physhm_unlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pipe() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI poll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI preadv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI profil() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pselect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_atfork() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_get_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getaffinity_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getdetachstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getguardsize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getinheritsched() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getschedpolicy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getscope() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getstack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getstackaddr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_getstacksize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setaffinity_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setcreatesuspend_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setdetachstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setguardsize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setinheritsched() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setschedpolicy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setscope() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setstack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setstackaddr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_attr_setstacksize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrier_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrier_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrier_setname_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrier_wait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrierattr_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrierattr_getpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrierattr_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_barrierattr_setpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cancel() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cleanup_pop() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cleanup_push() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_broadcast() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_reltimedwait_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_setname_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_signal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_signalto_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_timedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_cond_wait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_getclock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_getpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_setclock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_condattr_setpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_create() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_create_name_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_detach() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_equal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_exit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_get_specificarray_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_get_user_context_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getaffinity_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getconcurrency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getcpuclockid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getname_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getprio() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getspecific() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getstack_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_getthreadid_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_join() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_key_create() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_key_delete() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_kill() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_main_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_multi_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_getprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_getspinloops_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_getyieldloops_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_init_for_mono() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_isowned_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_lock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_reltimedlock_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_setname_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_setprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_setspinloops_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_setyieldloops_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_timedlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_trylock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutex_unlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_getkind_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_getprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_getprotocol() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_getpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_gettype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_setkind_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_setprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_setprotocol() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_setpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_mutexattr_settype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_once() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rename_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_resume_all_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_resume_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_resume_user_context_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_rdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_reltimedrdlock_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_reltimedwrlock_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_setname_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_timedrdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_timedwrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_tryrdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_trywrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_unlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlock_wrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_getpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_gettype_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_setpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_rwlockattr_settype_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_self() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_set_defaultstacksize_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_set_name_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_set_user_context_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setaffinity_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setcancelstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setcanceltype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setconcurrency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setprio() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_setspecific() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_sigmask() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_single_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_spin_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_spin_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_spin_lock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_spin_trylock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_spin_unlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_suspend_all_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_suspend_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_suspend_user_context_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_switch_add_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_switch_delete_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_testcancel() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_timedjoin_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pthread_yield() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pwrite() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI pwritev() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI raise() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI read() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI readv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI recv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI recvfrom() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI recvmsg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI rename() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI rfork_thread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI rmdir() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI rtld_printf() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI rtprio_thread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddCpumodeEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddFileEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddGpuExceptionEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddHRTimerEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddReadEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddTimerEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddUserEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddUserEventEdge() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAddWriteEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioCancelRequest() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioCancelRequests() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioDeleteRequest() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioDeleteRequests() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioInitializeImpl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioInitializeParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioPollRequest() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioPollRequests() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioSetParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioSubmitReadCommands() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioSubmitWriteCommands() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioWaitRequest() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAioWaitRequests() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAllocateDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAllocateDirectMemoryForMiniApp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAllocateMainDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAllocateTraceDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAvailableDirectMemorySize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelAvailableFlexibleMemorySize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelBacktraceSelf() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelBatchMap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelBatchMap2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCancelEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCancelSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCheckedReleaseDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCheckReachability() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelChmod() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClearBootReqNotifyCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClearEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClearGameDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClockGetres() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClockGettime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelClose() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCloseEport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCloseEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCloseSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelConfiguredFlexibleMemorySize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelConvertLocaltimeToUtc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelConvertUtcToLocaltime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCreateEport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCreateEqueue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCreateEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelCreateSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugAcquireAndUpdateDebugRegister() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugGetAppStatus() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugGetPauseCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugGpuPaDebugIsInProgress() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugOutText() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugRaiseException() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionOnReleaseMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionWithContext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionWithInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDebugReleaseDebugContext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteCpumodeEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteEport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteEqueue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteFileEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteGpuExceptionEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteHRTimerEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteReadEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteTimerEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteUserEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDeleteWriteEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDirectMemoryQuery() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDirectMemoryQueryForId() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelDlsym() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEnableDmemAliasing() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEnableDmemAliasing2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEnablePthreadObjectCheck() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelError() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEventLogInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEventLogPread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEventLogRead() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelEventLogWrite() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFchmod() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFcntl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFdatasync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFstat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFsync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFtruncate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelFutimes() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetAllowedSdkVersionOnSystem() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetAppInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetAslrStatus() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBackupRestoreMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBackupRestoreModeOfNextBoot() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBasicProductShape() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBetaUpdateTestForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBioUsageAll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetBootReqNotifyCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCallRecord() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersionByPath() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersionByPid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuFrequency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpumode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpumodeGame() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuTemperature() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuUsage() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuUsageAll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuUsageProc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuUsageProc2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCpuUsageThread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetCurrentCpu() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDataTransferMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDebugMenuMiniModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDebugMenuModeForPsmForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDebugMenuModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetdents() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDirectMemorySize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetDirectMemoryType() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetdirentries() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventData() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventError() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventFflags() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventFilter() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventId() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetEventUserData() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetExecutableModuleHandle() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetExtLibcHandle() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetFakeFinalizeMenuForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetFlagedUpdaterForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetForceUpdateModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetFsSandboxRandomWord() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetGPI() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetGPO() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetHwFeatureInfoForDecid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetIdPs() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetIdTableCurrentCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetIpcPath() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetLibkernelTextLocation() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetMainSocId() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleInfoForUnwind() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleInfoFromAddr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleInfoInternal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleList() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleListInternal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetOpenPsIdForSystem() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPageTableStats() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPagingStatsOfAllObjects() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPagingStatsOfAllThreads() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPhysPageSize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcessName() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcessTime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcessTimeCounter() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcessType() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProcParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProductCode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetProductStr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPrtAperture() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPsmIntdevModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetPsnAccessTraceLogForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetQafExpirationTimeNotafterForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetQafExpirationTimeNotbeforeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetQafGenerationForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetQafNameForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetRenderingMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetResidentCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetResidentFmemCount() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSafemode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSanitizerMallocReplace() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSanitizerMallocReplaceExternal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSanitizerNewReplace() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSanitizerNewReplaceExternal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSocPowerConsumption() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSocSensorTemperature() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSpecialIForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSubsysId() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSystemExVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSystemLevelDebuggerModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSystemSwBeta() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetSystemSwVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetThreadName() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGettimeofday() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGettimezone() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetTraceMemoryStats() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetTscFrequency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenDataExecutionForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenExpirationTimeNotafterForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenExpirationTimeNotbeforeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenFakeSharefactoryForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenFlagedUpdaterForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenNpEnvSwitchingForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenSaveDataRepairForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenStoreModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenUseSoftwagnerForAcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenUseSoftwagnerForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetUtokenWeakenedPortRestrictionForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetVrCaptureSize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelHasNeoMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelHwHasOpticalOut() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelHwHasWlanBt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccControlBDPowerState() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccControlUSBPowerState() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetBDPowerState() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetCountTime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetCPMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetCpuInfoBit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetErrLog() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetHwInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetPowerNumberOfBootShutdown() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetPowerOperatingTime() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetPowerUpCause() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetSysEventLog() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetThermalAlert() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccGetUSBPowerState() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccIndicatorBootDone() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccIndicatorShutdown() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccIndicatorStandby() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccIndicatorStandbyBoot() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccIndicatorStandbyShutdown() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccNotifyBootStatus() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccNvsFlush() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccReadPowerBootMessage() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccSetBuzzer() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccSetCPMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccSetCpuInfoBit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIccSetDownloadMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInstallExceptionHandler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalGetKmemStatistics() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalGetMapStatistics() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalHeapPrintBacktraceWithModuleInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalMapDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalMapNamedDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalMemoryGetAvailableSize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalMemoryGetModuleSegmentInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalResumeDirectMemoryRelease() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelInternalSuspendDirectMemoryRelease() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsAddressSanitizerEnabled() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsAllowedToSelectDvdRegion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsAuthenticNeo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsCEX() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsDebuggerAttached() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsDevKit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsExperimentalBeta() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsGenuineCEX() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsGenuineDevKit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsGenuineKratosCex() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsGenuineN() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsGenuineTestKit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsInSandbox() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsKratos() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsMainOnStanbyMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsMainOnStandbyMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsNeoMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsStack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsTestKit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelJitCreateAliasOfSharedMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelJitCreateSharedMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelJitGetSharedMemoryInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelJitMapSharedMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelKernelHeapUsage() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLoadStartModule() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLoadStartModuleForSysmodule() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLseek() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLwfsAllocateBlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLwfsLseek() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLwfsSetAttribute() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLwfsTrimBlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelLwfsWrite() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapDirectMemory2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapFlexibleMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapNamedDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapNamedFlexibleMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapNamedSystemFlexibleMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapSanitizerShadowMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMapTraceMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolBatch() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolCommit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolDecommit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolExpand() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolGetBlockStats() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolMove() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMemoryPoolReserve() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMkdir() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMlockall() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMmap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMprotect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMsync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMtypeprotect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMunlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMunlockall() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelMunmap() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelNanosleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelNormalizePath() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelNotifyAppStateChanged() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelNotifySystemSuspendResumeProgress() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelNotifySystemSuspendStart() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelOpen() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelOpenEport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelOpenEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelOpenSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPollEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPollSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPread() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPreadv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPrintBacktraceWithModuleInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelProtectDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelProtectDirectMemoryForPID() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPwrite() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelPwritev() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelQueryMemoryProtection() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelQueryTraceMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRaiseException() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRandomizedPath() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRdup() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRead() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReadTsc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReadv() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReboot() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReleaseDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReleaseFlexibleMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReleaseTraceDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRemoveExceptionHandler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRename() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReportUnpatchedFunctionCall() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReserve2mbPage() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReserveSystemDirectMemory() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelReserveVirtualRange() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelResumeDirectMemoryRelease() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRmdir() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelRtldControl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSandboxPath() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSendNotificationRequest() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetAppInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetBackupRestoreMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetBaseModeClock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetBesteffort() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetBootReqNotify() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetCallRecord() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetCompressionAttribute() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetCpumodeGame() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetDataTransferMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetFsstParam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetGameDirectMemoryLimit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetGPI() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetGPO() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetGpuCu() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetMemoryPstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetNeoModeClock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetPhysFmemLimit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetProcessName() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetProcessProperty() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetProcessPropertyString() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetPrtAperture() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetSafemode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSettimeofday() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetTimezoneInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetVirtualRangeName() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSetVmContainer() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSignalSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSlvNotifyError() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelStat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelStopUnloadModule() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSuspendDirectMemoryRelease() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSwitchToBaseMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSwitchToNeoMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelSync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTerminateSysCore() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTitleWorkaroundIsEnabled() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTitleWorkdaroundIsEnabled() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTraceMemoryTypeProtect() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTriggerEport() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTriggerUserEvent() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelTruncate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelUnlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelUsleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelUtimes() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelUuidCreate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelVirtualQuery() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelVirtualQueryAll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWaitEqueue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWaitEventFlag() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWaitSema() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWrite() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWriteSdkEventLog() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelWritev() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelYieldCpumode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceLibcMspaceCreateForMonoMutex() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAtfork() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGet() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetdetachstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetguardsize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetinheritsched() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetschedpolicy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetscope() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetstack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetstackaddr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrGetstacksize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetcreatesuspend() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetdetachstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetguardsize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetinheritsched() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetschedpolicy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetscope() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetstack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetstackaddr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadAttrSetstacksize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierattrDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierattrGetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierattrInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierattrSetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadBarrierWait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCancel() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrGetclock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrGetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrSetclock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondattrSetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondBroadcast() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondSignal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondSignalto() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondTimedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCondWait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadCreate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadDetach() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadEqual() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadExit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetconcurrency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetcpuclockid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetprio() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetspecific() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadGetthreadid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadJoin() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadKeyCreate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadKeyDelete() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMain() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMulti() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrGetkind() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrGetprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrGetprotocol() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrGetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrGettype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrInitForInternalLibc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrSetkind() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrSetprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrSetprotocol() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrSetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexattrSettype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexGetprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexGetspinloops() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexGetyieldloops() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexInitForInternalLibc() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexIsowned() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexLock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexSetprioceiling() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexSetspinloops() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexSetyieldloops() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexTimedlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexTrylock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadMutexUnlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadOnce() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRename() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadResume() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadResumeAll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrGetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrGettype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrSetpshared() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockattrSettype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockRdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockTimedrdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockTimedwrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockTryrdlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockTrywrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockUnlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadRwlockWrlock() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSelf() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemDestroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemGetvalue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemInit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemPost() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemTimedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemTrywait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSemWait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetaffinity() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetBesteffort() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetcancelstate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetcanceltype() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetconcurrency() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetDefaultstacksize() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetName() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetprio() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetschedparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSetspecific() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSingle() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSuspend() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadSuspendAll() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadTestcancel() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadTimedjoin() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI scePthreadYield() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_get_priority_max() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_get_priority_min() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_getparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_getscheduler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_rr_get_interval() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_setparam() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_setscheduler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sched_yield() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI select() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_close() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_destroy() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_getvalue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_init() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_post() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_reltimedwait_np() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_setname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_timedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_trywait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_unlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sem_wait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI send() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sendfile() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sendmsg() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sendto() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI set_phys_fmem_limit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setcontext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setegid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI seteuid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setgroups() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setitimer() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setpriority() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setregid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setreuid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setrlimit() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setsockopt() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI settimeofday() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI setuid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI shm_open() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI shm_unlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI shutdown() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigaction() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigaddset() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigaltstack() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigdelset() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigemptyset() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigfillset() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigismember() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI siglongjmp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI signal() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigpending() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigprocmask() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigqueue() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigreturn() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigsetjmp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigsuspend() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigtimedwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigwait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sigwaitinfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI socket() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI socketpair() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI stat() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI swapcontext() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sync() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysarch() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysconf() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysctl() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysctlbyname() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysctlnametomib() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysKernelGetIntdevModeForRcmgr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysKernelGetLowerLimitSysexVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysKernelGetLowerLimitUpdVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysKernelGetManufacturingMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysKernelGetUpdVersion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI system() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcdrain() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcflow() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcflush() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcgetattr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcgetpgrp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcgetsid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcsendbreak() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcsetattr() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcsetpgrp() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI tcsetsid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI truncate() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI unlink() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI usleep() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI utimes() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI uuidgen() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI wait() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI wait3() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI waitpid() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI write() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI writev() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_37DE1AD13E05E3E5() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_71A7C3C5AEB8B0EE() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_829822FC6C04D88B() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_866AB0F0694DFAD2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_8CCB8DA014423D48() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_AAD1CE2ED156ABB6() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_B95F988A5707A80B() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_BDF61AC64C672574() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_BFEA9394D8C5EA41() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_C740D02B44D70E4D() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_D6FDB7C3B4679227() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_DB02A3203D221953() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_DB1838257BDA27A9() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_FCF341DED7E70FC7() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_FEE3EAF3655B44C2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsProspero() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetOpenPsId() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_0A531D1EEBBE4750() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleInfo2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelGetModuleList2() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceKernelIsModuleLoaded() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysc_e00() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sysc_s00() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpAttachMemoryRegion() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpAttachMemoryRegionAsUserFile() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpAttachUserFile() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpAttachUserMemoryFile() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpConfigDumpMode() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpDebugTextOut() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpGetStopInfoCpu() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpGetStopInfoGpu() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpGetThreadContextInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpInternalGetThreadContextInfo() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpRegisterCoredumpHandler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpSetUserDataType() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpUnregisterCoredumpHandler() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpWriteUserData() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI Func_9889095293F9BCAA() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpDebugForceCoredumpOnAppClose() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump() { + LOG_ERROR(Kernel, "(STUBBED) called"); + return ORBIS_OK; +} + +void Registerlibkernel(Core::Loader::SymbolsResolver* sym){ + /* LIB_FUNCTION("Fjc4-n1+y2g", "libkernel", 1, "libkernel", 1, 1, __elf_phdr_match_addr); + LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __error); + LIB_FUNCTION("nSSPVGJLMjE", "libkernel", 1, "libkernel", 1, 1, __freeze); + LIB_FUNCTION("4pYihoPggn8", "libkernel", 1, "libkernel", 1, 1, __inet_ntop); + LIB_FUNCTION("fyPeCKJ94Hg", "libkernel", 1, "libkernel", 1, 1, __inet_pton); + LIB_FUNCTION("djxxOmW6-aw", "libkernel", 1, "libkernel", 1, 1, __progname); + LIB_FUNCTION("iWsFlYMf3Kw", "libkernel", 1, "libkernel", 1, 1, __pthread_cleanup_pop_imp); + LIB_FUNCTION("1xvtUVx1-Sg", "libkernel", 1, "libkernel", 1, 1, __pthread_cleanup_push_imp); + LIB_FUNCTION("kbw4UHHSYy0", "libkernel", 1, "libkernel", 1, 1, __pthread_cxa_finalize); + LIB_FUNCTION("3JYhkiIHkJc", "libkernel", 1, "libkernel", 1, 1, __sceKernelGetGPI); + LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, __stack_chk_fail); + LIB_FUNCTION("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, __stack_chk_guard); + LIB_FUNCTION("zdaF5N-Xe2M", "libkernel", 1, "libkernel", 1, 1, __sys_debug_init); + LIB_FUNCTION("YbAunrti+54", "libkernel", 1, "libkernel", 1, 1, __sys_dl_get_info); + LIB_FUNCTION("XujojypwYYc", "libkernel", 1, "libkernel", 1, 1, __sys_dl_get_list); + LIB_FUNCTION("7OpNDDNMJyo", "libkernel", 1, "libkernel", 1, 1, __sys_dl_get_metadata); + LIB_FUNCTION("K7xiuldOPKw", "libkernel", 1, "libkernel", 1, 1, + __sys_dynlib_get_info_for_libdbg); + LIB_FUNCTION("nTc+tFajGqQ", "libkernel", 1, "libkernel", 1, 1, __sys_dynlib_get_info2); + LIB_FUNCTION("vpo3SbGFuEk", "libkernel", 1, "libkernel", 1, 1, + __sys_dynlib_get_list_for_libdbg); + LIB_FUNCTION("P0jjY6bxakI", "libkernel", 1, "libkernel", 1, 1, __sys_dynlib_get_list2); + LIB_FUNCTION("nZHk+lpqwVQ", "libkernel", 1, "libkernel", 1, 1, __sys_dynlib_load_prx); + LIB_FUNCTION("nG-FYqFutUo", "libkernel", 1, "libkernel", 1, 1, __sys_get_proc_type_info); + LIB_FUNCTION("O-hEvSnv2o4", "libkernel", 1, "libkernel", 1, 1, __sys_is_development_mode); + LIB_FUNCTION("2M+dFM8Wmq4", "libkernel", 1, "libkernel", 1, 1, __sys_kqueueex); + LIB_FUNCTION("3CNY4Z0Luc8", "libkernel", 1, "libkernel", 1, 1, __sys_namedobj_create); + LIB_FUNCTION("E7CmfLfeSuQ", "libkernel", 1, "libkernel", 1, 1, __sys_namedobj_delete); + LIB_FUNCTION("UTR6wAkajxk", "libkernel", 1, "libkernel", 1, 1, __sys_netabort); + LIB_FUNCTION("zsTvhCDrOjQ", "libkernel", 1, "libkernel", 1, 1, __sys_netcontrol); + LIB_FUNCTION("X86Q0qQJ1m0", "libkernel", 1, "libkernel", 1, 1, __sys_netgetiflist); + LIB_FUNCTION("Wx2+2t1mX1E", "libkernel", 1, "libkernel", 1, 1, __sys_netgetsockinfo); + LIB_FUNCTION("iZFJYJJoZS8", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_disable); + LIB_FUNCTION("MGrj20+EK+U", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_enable); + LIB_FUNCTION("h+4DJpAXs4I", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_get_ctr); + LIB_FUNCTION("IglowNcOePQ", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_get_hw); + LIB_FUNCTION("vS-RnoD1BSY", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_set_ctl); + LIB_FUNCTION("ztNqqNCl1Tw", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_set_ctr); + LIB_FUNCTION("PIt9WYaoBqU", "libkernel", 1, "libkernel", 1, 1, __sys_opmc_set_hw); + LIB_FUNCTION("raO+bB7q2cY", "libkernel", 1, "libkernel", 1, 1, __sys_osem_close); + LIB_FUNCTION("kPGXeSQeoWc", "libkernel", 1, "libkernel", 1, 1, __sys_osem_open); + LIB_FUNCTION("n0ErFZ2hmKs", "libkernel", 1, "libkernel", 1, 1, __sys_randomized_path); + LIB_FUNCTION("9Iem9Wk07xU", "libkernel", 1, "libkernel", 1, 1, __sys_rdup); + LIB_FUNCTION("7NwggrWJ5cA", "libkernel", 1, "libkernel", 1, 1, __sys_regmgr_call); + LIB_FUNCTION("ByogDrS-Xw8", "libkernel", 1, "libkernel", 1, 1, __sys_set_uevt); + LIB_FUNCTION("t+rTx5NW+qU", "libkernel", 1, "libkernel", 1, 1, __sys_socketclose); + LIB_FUNCTION("pG70GT5yRo4", "libkernel", 1, "libkernel", 1, 1, __sys_socketex); + LIB_FUNCTION("EeVthQocE3Y", "libkernel", 1, "libkernel", 1, 1, __sys_test_debug_rwmem); + LIB_FUNCTION("jTPE1AS7uak", "libkernel", 1, "libkernel", 1, 1, __sys_workaround8849); + LIB_FUNCTION("vNe1w4diLCs", "libkernel", 1, "libkernel", 1, 1, __tls_get_addr); + LIB_FUNCTION("OjWstbIRPUo", "libkernel", 1, "libkernel", 1, 1, __Ux86_64_setcontext); + LIB_FUNCTION("B+zfF7bMswI", "libkernel", 1, "libkernel", 1, 1, _accept); + LIB_FUNCTION("4boImm4wxu0", "libkernel", 1, "libkernel", 1, 1, _bind); + LIB_FUNCTION("NNtFaKJbPt0", "libkernel", 1, "libkernel", 1, 1, _close); + LIB_FUNCTION("KFDGyLj80MY", "libkernel", 1, "libkernel", 1, 1, _connect); + LIB_FUNCTION("W8f1adVl+48", "libkernel", 1, "libkernel", 1, 1, _dup2); + LIB_FUNCTION("-3nj+K1elI0", "libkernel", 1, "libkernel", 1, 1, _execve); + LIB_FUNCTION("ScfDTOqLOMw", "libkernel", 1, "libkernel", 1, 1, _execvpe); + LIB_FUNCTION("6Z83sYWFlA8", "libkernel", 1, "libkernel", 1, 1, _exit); + LIB_FUNCTION("t0fXUzq61Z4", "libkernel", 1, "libkernel", 1, 1, _fcntl); + LIB_FUNCTION("cZq1zIzFN7s", "libkernel", 1, "libkernel", 1, 1, _fpathconf); + LIB_FUNCTION("A0O5kF5x4LQ", "libkernel", 1, "libkernel", 1, 1, _fstat); + LIB_FUNCTION("17Mfe1B3X6U", "libkernel", 1, "libkernel", 1, 1, _fstatfs); + LIB_FUNCTION("sfKygSjIbI8", "libkernel", 1, "libkernel", 1, 1, _getdirentries); + LIB_FUNCTION("rTNM7adVYog", "libkernel", 1, "libkernel", 1, 1, _getpeername); + LIB_FUNCTION("6Gwl39KKUEI", "libkernel", 1, "libkernel", 1, 1, _getsockname); + LIB_FUNCTION("cL2QUlo9Vnk", "libkernel", 1, "libkernel", 1, 1, _getsockopt); + LIB_FUNCTION("wW+k21cmbwQ", "libkernel", 1, "libkernel", 1, 1, _ioctl); + LIB_FUNCTION("crb5j7mkk1c", "libkernel", 1, "libkernel", 1, 1, _is_signal_return); + LIB_FUNCTION("6EYF3tXjXbU", "libkernel", 1, "libkernel", 1, 1, _listen); + LIB_FUNCTION("NhpspxdjEKU", "libkernel", 1, "libkernel", 1, 1, _nanosleep); + LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1, _open); + LIB_FUNCTION("bGVEgWXy6dg", "libkernel", 1, "libkernel", 1, 1, _openat); + LIB_FUNCTION("DRuBt2pvICk", "libkernel", 1, "libkernel", 1, 1, _read); + LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv); + LIB_FUNCTION("gPcQ3OrFBUA", "libkernel", 1, "libkernel", 1, 1, _recvfrom); + LIB_FUNCTION("PcKApW9kVoQ", "libkernel", 1, "libkernel", 1, 1, _recvmsg); + LIB_FUNCTION("p5EcQeEeJAE", "libkernel", 1, "libkernel", 1, 1, + _sceKernelRtldSetApplicationHeapAPI); + LIB_FUNCTION("8OnWXlgQlvo", "libkernel", 1, "libkernel", 1, 1, + _sceKernelRtldThreadAtexitDecrement); + LIB_FUNCTION("Tz4RNUCBbGI", "libkernel", 1, "libkernel", 1, 1, + _sceKernelRtldThreadAtexitIncrement); + LIB_FUNCTION("pB-yGZ2nQ9o", "libkernel", 1, "libkernel", 1, 1, _sceKernelSetThreadAtexitCount); + LIB_FUNCTION("WhCc1w3EhSI", "libkernel", 1, "libkernel", 1, 1, _sceKernelSetThreadAtexitReport); + LIB_FUNCTION("rNhWz+lvOMU", "libkernel", 1, "libkernel", 1, 1, _sceKernelSetThreadDtors); + LIB_FUNCTION("+L22kkFiXok", "libkernel", 1, "libkernel", 1, 1, _sendmsg); + LIB_FUNCTION("lvDhwhUC05E", "libkernel", 1, "libkernel", 1, 1, _sendto); + LIB_FUNCTION("a4KKvF-ME4M", "libkernel", 1, "libkernel", 1, 1, _setsockopt); + LIB_FUNCTION("UDCI-WazohQ", "libkernel", 1, "libkernel", 1, 1, _sigaction); + LIB_FUNCTION("nQVWJEGHObc", "libkernel", 1, "libkernel", 1, 1, _sigintr); + LIB_FUNCTION("6xVpy0Fdq+I", "libkernel", 1, "libkernel", 1, 1, _sigprocmask); + LIB_FUNCTION("9zpLsLESzTs", "libkernel", 1, "libkernel", 1, 1, _sigsuspend); + LIB_FUNCTION("04AjkP0jO9U", "libkernel", 1, "libkernel", 1, 1, _umtx_op); + LIB_FUNCTION("RFlsu7nfopM", "libkernel", 1, "libkernel", 1, 1, _wait4); + LIB_FUNCTION("FxVZqBAA7ks", "libkernel", 1, "libkernel", 1, 1, _write); + LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev); + LIB_FUNCTION("3e+4Iv7IJ8U", "libkernel", 1, "libkernel", 1, 1, accept); + LIB_FUNCTION("8vE6Z6VEYyk", "libkernel", 1, "libkernel", 1, 1, access); + LIB_FUNCTION("3SVaehJvYFk", "libkernel", 1, "libkernel", 1, 1, amd64_set_fsbase); + LIB_FUNCTION("KuOmgKoqCdY", "libkernel", 1, "libkernel", 1, 1, bind); + LIB_FUNCTION("-pOg5A6Yr6g", "libkernel", 1, "libkernel", 1, 1, blockpool_batch); + LIB_FUNCTION("99XpfyBTg9c", "libkernel", 1, "libkernel", 1, 1, blockpool_map); + LIB_FUNCTION("JVgZfJt3ZqQ", "libkernel", 1, "libkernel", 1, 1, blockpool_open); + LIB_FUNCTION("KZchfealTT4", "libkernel", 1, "libkernel", 1, 1, blockpool_unmap); + LIB_FUNCTION("6mMQ1MSPW-Q", "libkernel", 1, "libkernel", 1, 1, chdir); + LIB_FUNCTION("ixrw0h2tWuI", "libkernel", 1, "libkernel", 1, 1, chflags); + LIB_FUNCTION("z0dtnPxYgtg", "libkernel", 1, "libkernel", 1, 1, chmod); + LIB_FUNCTION("smIj7eqzZE8", "libkernel", 1, "libkernel", 1, 1, clock_getres); + LIB_FUNCTION("lLMT9vJAck0", "libkernel", 1, "libkernel", 1, 1, clock_gettime); + LIB_FUNCTION("d7nUj1LOdDU", "libkernel", 1, "libkernel", 1, 1, clock_settime); + LIB_FUNCTION("bY-PO6JhzhQ", "libkernel", 1, "libkernel", 1, 1, close); + LIB_FUNCTION("XVL8So3QJUk", "libkernel", 1, "libkernel", 1, 1, connect); + LIB_FUNCTION("Pdgml4rbxYk", "libkernel", 1, "libkernel", 1, 1, cpuset_getaffinity); + LIB_FUNCTION("DGY7qWLcHGA", "libkernel", 1, "libkernel", 1, 1, cpuset_getid); + LIB_FUNCTION("0Ma-LQjv6So", "libkernel", 1, "libkernel", 1, 1, cpuset_setaffinity); + LIB_FUNCTION("5AMS0IntU8I", "libkernel", 1, "libkernel", 1, 1, creat); + LIB_FUNCTION("oiT0vgzmW0M", "libkernel", 1, "libkernel", 1, 1, dlclose); + LIB_FUNCTION("ucFJiTO1EUw", "libkernel", 1, "libkernel", 1, 1, dlerror); + LIB_FUNCTION("UteVS6B1ZrU", "libkernel", 1, "libkernel", 1, 1, dlopen); + LIB_FUNCTION("biY+kcVB5D4", "libkernel", 1, "libkernel", 1, 1, dlsym); + LIB_FUNCTION("iiQjzvfWDq0", "libkernel", 1, "libkernel", 1, 1, dup); + LIB_FUNCTION("wdUufa9g-D8", "libkernel", 1, "libkernel", 1, 1, dup2); + LIB_FUNCTION("6eh9QGpaRWw", "libkernel", 1, "libkernel", 1, 1, dynlib_get_obj_member); + LIB_FUNCTION("+2thxYZ4syk", "libkernel", 1, "libkernel", 1, 1, _environ); + LIB_FUNCTION("8KHh+VefZDM", "libkernel", 1, "libkernel", 1, 1, _errno); + LIB_FUNCTION("KaK52lYTBIs", "libkernel", 1, "libkernel", 1, 1, execv); + LIB_FUNCTION("kdguLiAheLI", "libkernel", 1, "libkernel", 1, 1, execve); + LIB_FUNCTION("0NJDcQ2B8vE", "libkernel", 1, "libkernel", 1, 1, execvp); + LIB_FUNCTION("UJrQCyYpyic", "libkernel", 1, "libkernel", 1, 1, fchflags); + LIB_FUNCTION("n01yNbQO5W4", "libkernel", 1, "libkernel", 1, 1, fchmod); + LIB_FUNCTION("8nY19bKoiZk", "libkernel", 1, "libkernel", 1, 1, fcntl); + LIB_FUNCTION("KIbJFQ0I1Cg", "libkernel", 1, "libkernel", 1, 1, fdatasync); + LIB_FUNCTION("9eMlfusH4sU", "libkernel", 1, "libkernel", 1, 1, flock); + LIB_FUNCTION("mqQMh1zPPT8", "libkernel", 1, "libkernel", 1, 1, fstat); + LIB_FUNCTION("juWbTNM+8hw", "libkernel", 1, "libkernel", 1, 1, fsync); + LIB_FUNCTION("ih4CD9-gghM", "libkernel", 1, "libkernel", 1, 1, ftruncate); + LIB_FUNCTION("+0EDo7YzcoU", "libkernel", 1, "libkernel", 1, 1, futimes); + LIB_FUNCTION("igMefp4SAv0", "libkernel", 1, "libkernel", 1, 1, get_authinfo); + LIB_FUNCTION("wwyXc68wvnA", "libkernel", 1, "libkernel", 1, 1, get_module_info_list); + LIB_FUNCTION("WtR7OVvUgSo", "libkernel", 1, "libkernel", 1, 1, get_page_table_stats); + LIB_FUNCTION("fi+JX2wq2XU", "libkernel", 1, "libkernel", 1, 1, get_sdk_compiled_version); + LIB_FUNCTION("p2xgfB-30g8", "libkernel", 1, "libkernel", 1, 1, get_self_auth_info); + LIB_FUNCTION("Hx-KCms9n4s", "libkernel", 1, "libkernel", 1, 1, get_vm_map_timestamp); + LIB_FUNCTION("iKJMWrAumPE", "libkernel", 1, "libkernel", 1, 1, getargc); + LIB_FUNCTION("FJmglmTMdr4", "libkernel", 1, "libkernel", 1, 1, getargv); + LIB_FUNCTION("dar03AOn+nM", "libkernel", 1, "libkernel", 1, 1, getcontext); + LIB_FUNCTION("2G6i6hMIUUY", "libkernel", 1, "libkernel", 1, 1, getdents); + LIB_FUNCTION("f09KvIPy-QY", "libkernel", 1, "libkernel", 1, 1, getdirentries); + LIB_FUNCTION("sZuwaDPATKs", "libkernel", 1, "libkernel", 1, 1, getdtablesize); + LIB_FUNCTION("72rYuYoDTWk", "libkernel", 1, "libkernel", 1, 1, getegid); + LIB_FUNCTION("tvpHe5kBO4E", "libkernel", 1, "libkernel", 1, 1, geteuid); + LIB_FUNCTION("AfuS23bX6kg", "libkernel", 1, "libkernel", 1, 1, getgid); + LIB_FUNCTION("3yjZbSvan2g", "libkernel", 1, "libkernel", 1, 1, getgroups); + LIB_FUNCTION("J1H1QRCJf2Q", "libkernel", 1, "libkernel", 1, 1, getitimer); + LIB_FUNCTION("AfMxh2e9V3Q", "libkernel", 1, "libkernel", 1, 1, getlogin); + LIB_FUNCTION("78FiHequa9U", "libkernel", 1, "libkernel", 1, 1, getlogin_r); + LIB_FUNCTION("k+AXqu2-eBc", "libkernel", 1, "libkernel", 1, 1, getpagesize); + LIB_FUNCTION("TXFFFiNldU8", "libkernel", 1, "libkernel", 1, 1, getpeername); + LIB_FUNCTION("HoLVWNanBBc", "libkernel", 1, "libkernel", 1, 1, getpid); + LIB_FUNCTION("e6ovBo9ZvJc", "libkernel", 1, "libkernel", 1, 1, getppid); + LIB_FUNCTION("miQ1wVwSexE", "libkernel", 1, "libkernel", 1, 1, getpriority); + LIB_FUNCTION("Wh7HbV7JFqc", "libkernel", 1, "libkernel", 1, 1, getrlimit); + LIB_FUNCTION("hHlZQUnlxSM", "libkernel", 1, "libkernel", 1, 1, getrusage); + LIB_FUNCTION("gokWod7GAH4", "libkernel", 1, "libkernel", 1, 1, getsid); + LIB_FUNCTION("RenI1lL1WFk", "libkernel", 1, "libkernel", 1, 1, getsockname); + LIB_FUNCTION("6O8EwYOgH9Y", "libkernel", 1, "libkernel", 1, 1, getsockopt); + LIB_FUNCTION("n88vx3C5nW8", "libkernel", 1, "libkernel", 1, 1, gettimeofday); + LIB_FUNCTION("kg4x8Prhfxw", "libkernel", 1, "libkernel", 1, 1, getuid); + LIB_FUNCTION("K1S8oc61xiM", "libkernel", 1, "libkernel", 1, 1, htonl); + LIB_FUNCTION("jogUIsOV3-U", "libkernel", 1, "libkernel", 1, 1, htons); + LIB_FUNCTION("5jRCs2axtr4", "libkernel", 1, "libkernel", 1, 1, inet_ntop); + LIB_FUNCTION("4n51s0zEf0c", "libkernel", 1, "libkernel", 1, 1, inet_pton); + LIB_FUNCTION("PfccT7qURYE", "libkernel", 1, "libkernel", 1, 1, ioctl); + LIB_FUNCTION("Hk7iHmGxB18", "libkernel", 1, "libkernel", 1, 1, ipmimgr_call); + LIB_FUNCTION("WaThXSvAQNc", "libkernel", 1, "libkernel", 1, 1, is_in_sandbox); + LIB_FUNCTION("AxUhC3zNrhk", "libkernel", 1, "libkernel", 1, 1, issetugid); + LIB_FUNCTION("RW-GEfpnsqg", "libkernel", 1, "libkernel", 1, 1, kevent); + LIB_FUNCTION("W0xkN0+ZkCE", "libkernel", 1, "libkernel", 1, 1, kill); + LIB_FUNCTION("nh2IFMgKTv8", "libkernel", 1, "libkernel", 1, 1, kqueue); + LIB_FUNCTION("pv9M2jHJ6iw", "libkernel", 1, "libkernel", 1, 1, ksem_close); + LIB_FUNCTION("asSKL30+heA", "libkernel", 1, "libkernel", 1, 1, ksem_destroy); + LIB_FUNCTION("rOT0UMvtCCA", "libkernel", 1, "libkernel", 1, 1, ksem_getvalue); + LIB_FUNCTION("TEwqtzAmezo", "libkernel", 1, "libkernel", 1, 1, ksem_init); + LIB_FUNCTION("k5QQrJEpRYY", "libkernel", 1, "libkernel", 1, 1, ksem_open); + LIB_FUNCTION("s8gWJrY1W-k", "libkernel", 1, "libkernel", 1, 1, ksem_post); + LIB_FUNCTION("vE+WlomLSh4", "libkernel", 1, "libkernel", 1, 1, ksem_timedwait); + LIB_FUNCTION("gVaofuRvLdU", "libkernel", 1, "libkernel", 1, 1, ksem_trywait); + LIB_FUNCTION("tvkQRDe6hNo", "libkernel", 1, "libkernel", 1, 1, ksem_unlink); + LIB_FUNCTION("rQvMIxmFD6A", "libkernel", 1, "libkernel", 1, 1, ksem_wait); + LIB_FUNCTION("SFjw4+HOVOQ", "libkernel", 1, "libkernel", 1, 1, ktimer_create); + LIB_FUNCTION("Uyss1eAFtWo", "libkernel", 1, "libkernel", 1, 1, ktimer_delete); + LIB_FUNCTION("tj-nUlJCp-8", "libkernel", 1, "libkernel", 1, 1, ktimer_getoverrun); + LIB_FUNCTION("mZlElqorITk", "libkernel", 1, "libkernel", 1, 1, ktimer_gettime); + LIB_FUNCTION("ZWNwgNgglzA", "libkernel", 1, "libkernel", 1, 1, ktimer_settime); + LIB_FUNCTION("pxnCmagrtao", "libkernel", 1, "libkernel", 1, 1, listen); + LIB_FUNCTION("Oy6IpwgtYOk", "libkernel", 1, "libkernel", 1, 1, lseek); + LIB_FUNCTION("DRGXpDDh8Ng", "libkernel", 1, "libkernel", 1, 1, lstat); + LIB_FUNCTION("Jahsnh4KKkg", "libkernel", 1, "libkernel", 1, 1, madvise); + LIB_FUNCTION("LYbbZxXNAns", "libkernel", 1, "libkernel", 1, 1, mdbg_service); + LIB_FUNCTION("+hFjyohmOU0", "libkernel", 1, "libkernel", 1, 1, mincore); + LIB_FUNCTION("JGMio+21L4c", "libkernel", 1, "libkernel", 1, 1, mkdir); + LIB_FUNCTION("mTBZfEal2Bw", "libkernel", 1, "libkernel", 1, 1, mlock); + LIB_FUNCTION("x7g7Ebeo8-U", "libkernel", 1, "libkernel", 1, 1, mlockall); + LIB_FUNCTION("BPE9s9vQQXo", "libkernel", 1, "libkernel", 1, 1, mmap); + LIB_FUNCTION("YQOfxL4QfeU", "libkernel", 1, "libkernel", 1, 1, mprotect); + LIB_FUNCTION("tZY4+SZNFhA", "libkernel", 1, "libkernel", 1, 1, msync); + LIB_FUNCTION("OG4RsDwLguo", "libkernel", 1, "libkernel", 1, 1, munlock); + LIB_FUNCTION("NpLBpgVV7PU", "libkernel", 1, "libkernel", 1, 1, munlockall); + LIB_FUNCTION("UqDGjXA5yUM", "libkernel", 1, "libkernel", 1, 1, munmap); + LIB_FUNCTION("yS8U2TGCe1A", "libkernel", 1, "libkernel", 1, 1, nanosleep); + LIB_FUNCTION("jct5WjixLgk", "libkernel", 1, "libkernel", 1, 1, ntohl); + LIB_FUNCTION("oLFi+HuZ7hY", "libkernel", 1, "libkernel", 1, 1, ntohs); + LIB_FUNCTION("wuCroIGjt2g", "libkernel", 1, "libkernel", 1, 1, open); + LIB_FUNCTION("EDyhWelj7UY", "libkernel", 1, "libkernel", 1, 1, pause); + LIB_FUNCTION("n371J5cP+uo", "libkernel", 1, "libkernel", 1, 1, physhm_open); + LIB_FUNCTION("AUqJNkobQ1c", "libkernel", 1, "libkernel", 1, 1, physhm_unlink); + LIB_FUNCTION("-Jp7F+pXxNg", "libkernel", 1, "libkernel", 1, 1, pipe); + LIB_FUNCTION("ku7D4q1Y9PI", "libkernel", 1, "libkernel", 1, 1, poll); + LIB_FUNCTION("ezv-RSBNKqI", "libkernel", 1, "libkernel", 1, 1, pread); + LIB_FUNCTION("ZaRzaapAZwM", "libkernel", 1, "libkernel", 1, 1, preadv); + LIB_FUNCTION("CpF21FIEKVQ", "libkernel", 1, "libkernel", 1, 1, profil); + LIB_FUNCTION("ZO2nWoTAv60", "libkernel", 1, "libkernel", 1, 1, pselect); + LIB_FUNCTION("U9t5kJAWPnA", "libkernel", 1, "libkernel", 1, 1, pthread_atfork); + LIB_FUNCTION("zHchY8ft5pk", "libkernel", 1, "libkernel", 1, 1, pthread_attr_destroy); + LIB_FUNCTION("Ucsu-OK+els", "libkernel", 1, "libkernel", 1, 1, pthread_attr_get_np); + LIB_FUNCTION("-wzZ7dvA7UU", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getaffinity_np); + LIB_FUNCTION("VUT1ZSrHT0I", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getdetachstate); + LIB_FUNCTION("JNkVVsVDmOk", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getguardsize); + LIB_FUNCTION("oLjPqUKhzes", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getinheritsched); + LIB_FUNCTION("qlk9pSLsUmM", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getschedparam); + LIB_FUNCTION("RtLRV-pBTTY", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getschedpolicy); + LIB_FUNCTION("e2G+cdEkOmU", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getscope); + LIB_FUNCTION("vQm4fDEsWi8", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getstack); + LIB_FUNCTION("DxmIMUQ-wXY", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getstackaddr); + LIB_FUNCTION("0qOtCR-ZHck", "libkernel", 1, "libkernel", 1, 1, pthread_attr_getstacksize); + LIB_FUNCTION("wtkt-teR1so", "libkernel", 1, "libkernel", 1, 1, pthread_attr_init); + LIB_FUNCTION("o8pd4juNbgc", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setaffinity_np); + LIB_FUNCTION("Q2y5IqSDZGs", "libkernel", 1, "libkernel", 1, 1, + pthread_attr_setcreatesuspend_np); + LIB_FUNCTION("E+tyo3lp5Lw", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setdetachstate); + LIB_FUNCTION("JKyG3SWyA10", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setguardsize); + LIB_FUNCTION("7ZlAakEf0Qg", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setinheritsched); + LIB_FUNCTION("euKRgm0Vn2M", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setschedparam); + LIB_FUNCTION("JarMIy8kKEY", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setschedpolicy); + LIB_FUNCTION("xesmlSI-KCI", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setscope); + LIB_FUNCTION("-SrbXpGR1f0", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setstack); + LIB_FUNCTION("suCrEbr0xIQ", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setstackaddr); + LIB_FUNCTION("2Q0z6rnBrTE", "libkernel", 1, "libkernel", 1, 1, pthread_attr_setstacksize); + LIB_FUNCTION("+Pqub9HZCPo", "libkernel", 1, "libkernel", 1, 1, pthread_barrier_destroy); + LIB_FUNCTION("ZsXLFtd2jqQ", "libkernel", 1, "libkernel", 1, 1, pthread_barrier_init); + LIB_FUNCTION("WwRRAkhjARM", "libkernel", 1, "libkernel", 1, 1, pthread_barrier_setname_np); + LIB_FUNCTION("CawZgCYqXWk", "libkernel", 1, "libkernel", 1, 1, pthread_barrier_wait); + LIB_FUNCTION("AsCQCYTbe80", "libkernel", 1, "libkernel", 1, 1, pthread_barrierattr_destroy); + LIB_FUNCTION("a5JZMyjFV68", "libkernel", 1, "libkernel", 1, 1, pthread_barrierattr_getpshared); + LIB_FUNCTION("4nqCnLJSvck", "libkernel", 1, "libkernel", 1, 1, pthread_barrierattr_init); + LIB_FUNCTION("jqrGJJxFhmU", "libkernel", 1, "libkernel", 1, 1, pthread_barrierattr_setpshared); + LIB_FUNCTION("0D4-FVvEikw", "libkernel", 1, "libkernel", 1, 1, pthread_cancel); + LIB_FUNCTION("RVxb0Ssa5t0", "libkernel", 1, "libkernel", 1, 1, pthread_cleanup_pop); + LIB_FUNCTION("4ZeZWcMsAV0", "libkernel", 1, "libkernel", 1, 1, pthread_cleanup_push); + LIB_FUNCTION("mkx2fVhNMsg", "libkernel", 1, "libkernel", 1, 1, pthread_cond_broadcast); + LIB_FUNCTION("RXXqi4CtF8w", "libkernel", 1, "libkernel", 1, 1, pthread_cond_destroy); + LIB_FUNCTION("0TyVk4MSLt0", "libkernel", 1, "libkernel", 1, 1, pthread_cond_init); + LIB_FUNCTION("K953PF5u6Pc", "libkernel", 1, "libkernel", 1, 1, pthread_cond_reltimedwait_np); + LIB_FUNCTION("EZ8h70dtFLg", "libkernel", 1, "libkernel", 1, 1, pthread_cond_setname_np); + LIB_FUNCTION("2MOy+rUfuhQ", "libkernel", 1, "libkernel", 1, 1, pthread_cond_signal); + LIB_FUNCTION("CI6Qy73ae10", "libkernel", 1, "libkernel", 1, 1, pthread_cond_signalto_np); + LIB_FUNCTION("27bAgiJmOh0", "libkernel", 1, "libkernel", 1, 1, pthread_cond_timedwait); + LIB_FUNCTION("Op8TBGY5KHg", "libkernel", 1, "libkernel", 1, 1, pthread_cond_wait); + LIB_FUNCTION("dJcuQVn6-Iw", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_destroy); + LIB_FUNCTION("cTDYxTUNPhM", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_getclock); + LIB_FUNCTION("h0qUqSuOmC8", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_getpshared); + LIB_FUNCTION("mKoTx03HRWA", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_init); + LIB_FUNCTION("EjllaAqAPZo", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_setclock); + LIB_FUNCTION("3BpP850hBT4", "libkernel", 1, "libkernel", 1, 1, pthread_condattr_setpshared); + LIB_FUNCTION("OxhIB8LB-PQ", "libkernel", 1, "libkernel", 1, 1, pthread_create); + LIB_FUNCTION("Jmi+9w9u0E4", "libkernel", 1, "libkernel", 1, 1, pthread_create_name_np); + LIB_FUNCTION("+U1R4WtXvoc", "libkernel", 1, "libkernel", 1, 1, pthread_detach); + LIB_FUNCTION("7Xl257M4VNI", "libkernel", 1, "libkernel", 1, 1, pthread_equal); + LIB_FUNCTION("FJrT5LuUBAU", "libkernel", 1, "libkernel", 1, 1, pthread_exit); + LIB_FUNCTION("td+DYvbbDfk", "libkernel", 1, "libkernel", 1, 1, pthread_get_specificarray_np); + LIB_FUNCTION("YkGOXpJEtO8", "libkernel", 1, "libkernel", 1, 1, pthread_get_user_context_np); + LIB_FUNCTION("Jb2uGFMr688", "libkernel", 1, "libkernel", 1, 1, pthread_getaffinity_np); + LIB_FUNCTION("s+QHU9RLHS4", "libkernel", 1, "libkernel", 1, 1, pthread_getconcurrency); + LIB_FUNCTION("nnoxZUHK+SA", "libkernel", 1, "libkernel", 1, 1, pthread_getcpuclockid); + LIB_FUNCTION("9HzfhdtESio", "libkernel", 1, "libkernel", 1, 1, pthread_getname_np); + LIB_FUNCTION("aO+WS2xWuo4", "libkernel", 1, "libkernel", 1, 1, pthread_getprio); + LIB_FUNCTION("FIs3-UQT9sg", "libkernel", 1, "libkernel", 1, 1, pthread_getschedparam); + LIB_FUNCTION("0-KXaS70xy4", "libkernel", 1, "libkernel", 1, 1, pthread_getspecific); + LIB_FUNCTION("ruZ9hhQ8oUk", "libkernel", 1, "libkernel", 1, 1, pthread_getstack_np); + LIB_FUNCTION("3eqs37G74-s", "libkernel", 1, "libkernel", 1, 1, pthread_getthreadid_np); + LIB_FUNCTION("h9CcP3J0oVM", "libkernel", 1, "libkernel", 1, 1, pthread_join); + LIB_FUNCTION("mqULNdimTn0", "libkernel", 1, "libkernel", 1, 1, pthread_key_create); + LIB_FUNCTION("6BpEZuDT7YI", "libkernel", 1, "libkernel", 1, 1, pthread_key_delete); + LIB_FUNCTION("yH-uQW3LbX0", "libkernel", 1, "libkernel", 1, 1, pthread_kill); + LIB_FUNCTION("D1D6GFIYYGs", "libkernel", 1, "libkernel", 1, 1, pthread_main_np); + LIB_FUNCTION("vhcrecqZy-k", "libkernel", 1, "libkernel", 1, 1, pthread_multi_np); + LIB_FUNCTION("ltCfaGr2JGE", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_destroy); + LIB_FUNCTION("itv-U5mFPso", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_getprioceiling); + LIB_FUNCTION("x4vQj3JKKmc", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_getspinloops_np); + LIB_FUNCTION("OxEIUqkByy4", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_getyieldloops_np); + LIB_FUNCTION("ttHNfU+qDBU", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_init); + LIB_FUNCTION("hLoEhSBhi84", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_init_for_mono); + LIB_FUNCTION("gKqzW-zWhvY", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_isowned_np); + LIB_FUNCTION("7H0iTOciTLo", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_lock); + LIB_FUNCTION("nbQ0bXMRlhk", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_reltimedlock_np); + LIB_FUNCTION("nTxZBp8YNGc", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_setname_np); + LIB_FUNCTION("XS3kGVt4q+4", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_setprioceiling); + LIB_FUNCTION("5-ncLMtL5+g", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_setspinloops_np); + LIB_FUNCTION("frFuGprJmPc", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_setyieldloops_np); + LIB_FUNCTION("Io9+nTKXZtA", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_timedlock); + LIB_FUNCTION("K-jXhbt2gn4", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_trylock); + LIB_FUNCTION("2Z+PpY6CaJg", "libkernel", 1, "libkernel", 1, 1, pthread_mutex_unlock); + LIB_FUNCTION("HF7lK46xzjY", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_destroy); + LIB_FUNCTION("U6SNV+RnyLQ", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_getkind_np); + LIB_FUNCTION("+m8+quqOwhM", "libkernel", 1, "libkernel", 1, 1, + pthread_mutexattr_getprioceiling); + LIB_FUNCTION("yDaWxUE50s0", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_getprotocol); + LIB_FUNCTION("PmL-TwKUzXI", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_getpshared); + LIB_FUNCTION("GZFlI7RhuQo", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_gettype); + LIB_FUNCTION("dQHWEsJtoE4", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_init); + LIB_FUNCTION("J9rlRuQ8H5s", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_setkind_np); + LIB_FUNCTION("ZLvf6lVAc4M", "libkernel", 1, "libkernel", 1, 1, + pthread_mutexattr_setprioceiling); + LIB_FUNCTION("5txKfcMUAok", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_setprotocol); + LIB_FUNCTION("EXv3ztGqtDM", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_setpshared); + LIB_FUNCTION("mDmgMOGVUqg", "libkernel", 1, "libkernel", 1, 1, pthread_mutexattr_settype); + LIB_FUNCTION("Z4QosVuAsA0", "libkernel", 1, "libkernel", 1, 1, pthread_once); + LIB_FUNCTION("9vyP6Z7bqzc", "libkernel", 1, "libkernel", 1, 1, pthread_rename_np); + LIB_FUNCTION("3gY5B0FCkNY", "libkernel", 1, "libkernel", 1, 1, pthread_resume_all_np); + LIB_FUNCTION("BYM3L--ojzI", "libkernel", 1, "libkernel", 1, 1, pthread_resume_np); + LIB_FUNCTION("QRdE7dBfNks", "libkernel", 1, "libkernel", 1, 1, pthread_resume_user_context_np); + LIB_FUNCTION("1471ajPzxh0", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_destroy); + LIB_FUNCTION("ytQULN-nhL4", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_init); + LIB_FUNCTION("iGjsr1WAtI0", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_rdlock); + LIB_FUNCTION("dYv-+If2GPk", "libkernel", 1, "libkernel", 1, 1, + pthread_rwlock_reltimedrdlock_np); + LIB_FUNCTION("RRnSj8h8VR4", "libkernel", 1, "libkernel", 1, 1, + pthread_rwlock_reltimedwrlock_np); + LIB_FUNCTION("Uwxgnsi3xeM", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_setname_np); + LIB_FUNCTION("lb8lnYo-o7k", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_timedrdlock); + LIB_FUNCTION("9zklzAl9CGM", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_timedwrlock); + LIB_FUNCTION("SFxTMOfuCkE", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_tryrdlock); + LIB_FUNCTION("XhWHn6P5R7U", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_trywrlock); + LIB_FUNCTION("EgmLo6EWgso", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_unlock); + LIB_FUNCTION("sIlRvQqsN2Y", "libkernel", 1, "libkernel", 1, 1, pthread_rwlock_wrlock); + LIB_FUNCTION("qsdmgXjqSgk", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_destroy); + LIB_FUNCTION("VqEMuCv-qHY", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_getpshared); + LIB_FUNCTION("l+bG5fsYkhg", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_gettype_np); + LIB_FUNCTION("xFebsA4YsFI", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_init); + LIB_FUNCTION("OuKg+kRDD7U", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_setpshared); + LIB_FUNCTION("8NuOHiTr1Vw", "libkernel", 1, "libkernel", 1, 1, pthread_rwlockattr_settype_np); + LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, pthread_self); + LIB_FUNCTION("tG+805b1Njk", "libkernel", 1, "libkernel", 1, 1, pthread_set_defaultstacksize_np); + LIB_FUNCTION("oxMp8uPqa+U", "libkernel", 1, "libkernel", 1, 1, pthread_set_name_np); + LIB_FUNCTION("el9stmu6290", "libkernel", 1, "libkernel", 1, 1, pthread_set_user_context_np); + LIB_FUNCTION("5KWrg7-ZqvE", "libkernel", 1, "libkernel", 1, 1, pthread_setaffinity_np); + LIB_FUNCTION("lZzFeSxPl08", "libkernel", 1, "libkernel", 1, 1, pthread_setcancelstate); + LIB_FUNCTION("2dEhvvjlq30", "libkernel", 1, "libkernel", 1, 1, pthread_setcanceltype); + LIB_FUNCTION("fBG1gHx1RlI", "libkernel", 1, "libkernel", 1, 1, pthread_setconcurrency); + LIB_FUNCTION("a2P9wYGeZvc", "libkernel", 1, "libkernel", 1, 1, pthread_setprio); + LIB_FUNCTION("Xs9hdiD7sAA", "libkernel", 1, "libkernel", 1, 1, pthread_setschedparam); + LIB_FUNCTION("WrOLvHU0yQM", "libkernel", 1, "libkernel", 1, 1, pthread_setspecific); + LIB_FUNCTION("JZKw5+Wrnaw", "libkernel", 1, "libkernel", 1, 1, pthread_sigmask); + LIB_FUNCTION("4Q8db4pIRV0", "libkernel", 1, "libkernel", 1, 1, pthread_single_np); + LIB_FUNCTION("IJIggoPZExk", "libkernel", 1, "libkernel", 1, 1, pthread_spin_destroy); + LIB_FUNCTION("ZMn3clnAGBA", "libkernel", 1, "libkernel", 1, 1, pthread_spin_init); + LIB_FUNCTION("pw+70ClLYlY", "libkernel", 1, "libkernel", 1, 1, pthread_spin_lock); + LIB_FUNCTION("rCTGkBIHfPY", "libkernel", 1, "libkernel", 1, 1, pthread_spin_trylock); + LIB_FUNCTION("LEfMMCT+SlM", "libkernel", 1, "libkernel", 1, 1, pthread_spin_unlock); + LIB_FUNCTION("iWAnZ3ger+8", "libkernel", 1, "libkernel", 1, 1, pthread_suspend_all_np); + LIB_FUNCTION("4e9dMKt+UYA", "libkernel", 1, "libkernel", 1, 1, pthread_suspend_np); + LIB_FUNCTION("cfjAjVTFG6A", "libkernel", 1, "libkernel", 1, 1, pthread_suspend_user_context_np); + LIB_FUNCTION("Q9DhUQxNCwI", "libkernel", 1, "libkernel", 1, 1, pthread_switch_add_np); + LIB_FUNCTION("neZ60m-+Baw", "libkernel", 1, "libkernel", 1, 1, pthread_switch_delete_np); + LIB_FUNCTION("nYBrkGDqxh8", "libkernel", 1, "libkernel", 1, 1, pthread_testcancel); + LIB_FUNCTION("PkS44IGrDkM", "libkernel", 1, "libkernel", 1, 1, pthread_timedjoin_np); + LIB_FUNCTION("B5GmVDKwpn0", "libkernel", 1, "libkernel", 1, 1, pthread_yield); + LIB_FUNCTION("C2kJ-byS5rM", "libkernel", 1, "libkernel", 1, 1, pwrite); + LIB_FUNCTION("FCcmRZhWtOk", "libkernel", 1, "libkernel", 1, 1, pwritev); + LIB_FUNCTION("0t0-MxQNwK4", "libkernel", 1, "libkernel", 1, 1, raise); + LIB_FUNCTION("AqBioC2vF3I", "libkernel", 1, "libkernel", 1, 1, read); + LIB_FUNCTION("I7ImcLds-uU", "libkernel", 1, "libkernel", 1, 1, readv); + LIB_FUNCTION("Ez8xjo9UF4E", "libkernel", 1, "libkernel", 1, 1, recv); + LIB_FUNCTION("lUk6wrGXyMw", "libkernel", 1, "libkernel", 1, 1, recvfrom); + LIB_FUNCTION("hI7oVeOluPM", "libkernel", 1, "libkernel", 1, 1, recvmsg); + LIB_FUNCTION("NN01qLRhiqU", "libkernel", 1, "libkernel", 1, 1, rename); + LIB_FUNCTION("bSDxEpGzmUE", "libkernel", 1, "libkernel", 1, 1, rfork_thread); + LIB_FUNCTION("c7ZnT7V1B98", "libkernel", 1, "libkernel", 1, 1, rmdir); + LIB_FUNCTION("u8M56qpqTtw", "libkernel", 1, "libkernel", 1, 1, rtld_printf); + LIB_FUNCTION("2I2RV6LyNng", "libkernel", 1, "libkernel", 1, 1, rtprio_thread); + LIB_FUNCTION("NhL5qID2iho", "libkernel", 1, "libkernel", 1, 1, sceKernelAddCpumodeEvent); + LIB_FUNCTION("cG3t15OK4Ow", "libkernel", 1, "libkernel", 1, 1, sceKernelAddFileEvent); + LIB_FUNCTION("YJ7JscWubcU", "libkernel", 1, "libkernel", 1, 1, sceKernelAddGpuExceptionEvent); + LIB_FUNCTION("R74tt43xP6k", "libkernel", 1, "libkernel", 1, 1, sceKernelAddHRTimerEvent); + LIB_FUNCTION("VHCS3rCd0PM", "libkernel", 1, "libkernel", 1, 1, sceKernelAddReadEvent); + LIB_FUNCTION("57ZK+ODEXWY", "libkernel", 1, "libkernel", 1, 1, sceKernelAddTimerEvent); + LIB_FUNCTION("4R6-OvI2cEA", "libkernel", 1, "libkernel", 1, 1, sceKernelAddUserEvent); + LIB_FUNCTION("WDszmSbWuDk", "libkernel", 1, "libkernel", 1, 1, sceKernelAddUserEventEdge); + LIB_FUNCTION("R-tyYMpYaxY", "libkernel", 1, "libkernel", 1, 1, sceKernelAddWriteEvent); + LIB_FUNCTION("fR521KIGgb8", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequest); + LIB_FUNCTION("3Lca1XBrQdY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioCancelRequests); + LIB_FUNCTION("5TgME6AYty4", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequest); + LIB_FUNCTION("Ft3EtsZzAoY", "libkernel", 1, "libkernel", 1, 1, sceKernelAioDeleteRequests); + LIB_FUNCTION("vYU8P9Td2Zo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeImpl); + LIB_FUNCTION("nu4a0-arQis", "libkernel", 1, "libkernel", 1, 1, sceKernelAioInitializeParam); + LIB_FUNCTION("2pOuoWoCxdk", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequest); + LIB_FUNCTION("o7O4z3jwKzo", "libkernel", 1, "libkernel", 1, 1, sceKernelAioPollRequests); + LIB_FUNCTION("9WK-vhNXimw", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSetParam); + LIB_FUNCTION("HgX7+AORI58", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitReadCommands); + LIB_FUNCTION("lXT0m3P-vs4", "libkernel", 1, "libkernel", 1, 1, + sceKernelAioSubmitReadCommandsMultiple); + LIB_FUNCTION("XQ8C8y+de+E", "libkernel", 1, "libkernel", 1, 1, sceKernelAioSubmitWriteCommands); + LIB_FUNCTION("xT3Cpz0yh6Y", "libkernel", 1, "libkernel", 1, 1, + sceKernelAioSubmitWriteCommandsMultiple); + LIB_FUNCTION("KOF-oJbQVvc", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequest); + LIB_FUNCTION("lgK+oIWkJyA", "libkernel", 1, "libkernel", 1, 1, sceKernelAioWaitRequests); + LIB_FUNCTION("rTXw65xmLIA", "libkernel", 1, "libkernel", 1, 1, sceKernelAllocateDirectMemory); + LIB_FUNCTION("ll8I9K4RtUM", "libkernel", 1, "libkernel", 1, 1, + sceKernelAllocateDirectMemoryForMiniApp); + LIB_FUNCTION("B+vc2AO2Zrc", "libkernel", 1, "libkernel", 1, 1, + sceKernelAllocateMainDirectMemory); + LIB_FUNCTION("g6fhW-+NuuU", "libkernel", 1, "libkernel", 1, 1, + sceKernelAllocateTraceDirectMemory); + LIB_FUNCTION("C0f7TJcbfac", "libkernel", 1, "libkernel", 1, 1, + sceKernelAvailableDirectMemorySize); + LIB_FUNCTION("aNz11fnnzi4", "libkernel", 1, "libkernel", 1, 1, + sceKernelAvailableFlexibleMemorySize); + LIB_FUNCTION("xRwvvcfZfHM", "libkernel", 1, "libkernel", 1, 1, sceKernelBacktraceSelf); + LIB_FUNCTION("2SKEx6bSq-4", "libkernel", 1, "libkernel", 1, 1, sceKernelBatchMap); + LIB_FUNCTION("kBJzF8x4SyE", "libkernel", 1, "libkernel", 1, 1, sceKernelBatchMap2); + LIB_FUNCTION("PZku4ZrXJqg", "libkernel", 1, "libkernel", 1, 1, sceKernelCancelEventFlag); + LIB_FUNCTION("4DM06U2BNEY", "libkernel", 1, "libkernel", 1, 1, sceKernelCancelSema); + LIB_FUNCTION("hwVSPCmp5tM", "libkernel", 1, "libkernel", 1, 1, + sceKernelCheckedReleaseDirectMemory); + LIB_FUNCTION("uWyW3v98sU4", "libkernel", 1, "libkernel", 1, 1, sceKernelCheckReachability); + LIB_FUNCTION("fgIsQ10xYVA", "libkernel", 1, "libkernel", 1, 1, sceKernelChmod); + LIB_FUNCTION("N9SrpMINuLw", "libkernel", 1, "libkernel", 1, 1, + sceKernelClearBootReqNotifyCount); + LIB_FUNCTION("7uhBFWRAS60", "libkernel", 1, "libkernel", 1, 1, sceKernelClearEventFlag); + LIB_FUNCTION("EgJqC+9VmvM", "libkernel", 1, "libkernel", 1, 1, sceKernelClearGameDirectMemory); + LIB_FUNCTION("wRYVA5Zolso", "libkernel", 1, "libkernel", 1, 1, sceKernelClockGetres); + LIB_FUNCTION("QBi7HCK03hw", "libkernel", 1, "libkernel", 1, 1, sceKernelClockGettime); + LIB_FUNCTION("UK2Tl2DWUns", "libkernel", 1, "libkernel", 1, 1, sceKernelClose); + LIB_FUNCTION("J5RqzZ7nMVc", "libkernel", 1, "libkernel", 1, 1, sceKernelCloseEport); + LIB_FUNCTION("s9-RaxukuzQ", "libkernel", 1, "libkernel", 1, 1, sceKernelCloseEventFlag); + LIB_FUNCTION("HBkUky2PZPA", "libkernel", 1, "libkernel", 1, 1, sceKernelCloseSema); + LIB_FUNCTION("n1-v6FgU7MQ", "libkernel", 1, "libkernel", 1, 1, + sceKernelConfiguredFlexibleMemorySize); + LIB_FUNCTION("0NTHN1NKONI", "libkernel", 1, "libkernel", 1, 1, sceKernelConvertLocaltimeToUtc); + LIB_FUNCTION("-o5uEDpN+oY", "libkernel", 1, "libkernel", 1, 1, sceKernelConvertUtcToLocaltime); + LIB_FUNCTION("KF25CDxFn48", "libkernel", 1, "libkernel", 1, 1, sceKernelCreateEport); + LIB_FUNCTION("D0OdFMjp46I", "libkernel", 1, "libkernel", 1, 1, sceKernelCreateEqueue); + LIB_FUNCTION("BpFoboUJoZU", "libkernel", 1, "libkernel", 1, 1, sceKernelCreateEventFlag); + LIB_FUNCTION("188x57JYp0g", "libkernel", 1, "libkernel", 1, 1, sceKernelCreateSema); + LIB_FUNCTION("FMvo0UFMf-o", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugAcquireAndUpdateDebugRegister); + LIB_FUNCTION("XECwgo2nbek", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugGetAppStatus); + LIB_FUNCTION("CgfvQDFAtYU", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugGetPauseCount); + LIB_FUNCTION("+iVwFsjXaFQ", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugGpuPaDebugIsInProgress); + LIB_FUNCTION("9JYNqN6jAKI", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugOutText); + LIB_FUNCTION("OMDRKKAZ8I4", "libkernel", 1, "libkernel", 1, 1, sceKernelDebugRaiseException); + LIB_FUNCTION("zE-wXIZjLoM", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugRaiseExceptionOnReleaseMode); + LIB_FUNCTION("DKWTYfo-jMY", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugRaiseExceptionWithContext); + LIB_FUNCTION("HbRSpVkdVF0", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugRaiseExceptionWithInfo); + LIB_FUNCTION("8rHK-6bbvqM", "libkernel", 1, "libkernel", 1, 1, + sceKernelDebugReleaseDebugContext); + LIB_FUNCTION("OwjivtyfODU", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteCpumodeEvent); + LIB_FUNCTION("HhGAQ+ffliw", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteEport); + LIB_FUNCTION("jpFjmgAC5AE", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteEqueue); + LIB_FUNCTION("8mql9OcQnd4", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteEventFlag); + LIB_FUNCTION("UmXngHKB6is", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteFileEvent); + LIB_FUNCTION("8skggWXlSqM", "libkernel", 1, "libkernel", 1, 1, + sceKernelDeleteGpuExceptionEvent); + LIB_FUNCTION("J+LF6LwObXU", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteHRTimerEvent); + LIB_FUNCTION("JxJ4tfgKlXA", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteReadEvent); + LIB_FUNCTION("R1Jvn8bSCW8", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteSema); + LIB_FUNCTION("YWQFUyXIVdU", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteTimerEvent); + LIB_FUNCTION("LJDwdSNTnDg", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteUserEvent); + LIB_FUNCTION("cBGTk8S92XM", "libkernel", 1, "libkernel", 1, 1, sceKernelDeleteWriteEvent); + LIB_FUNCTION("BHouLQzh0X0", "libkernel", 1, "libkernel", 1, 1, sceKernelDirectMemoryQuery); + LIB_FUNCTION("ZB9HZnouJrc", "libkernel", 1, "libkernel", 1, 1, sceKernelDirectMemoryQueryForId); + LIB_FUNCTION("LwG8g3niqwA", "libkernel", 1, "libkernel", 1, 1, sceKernelDlsym); + LIB_FUNCTION("usHTMoFoBTM", "libkernel", 1, "libkernel", 1, 1, sceKernelEnableDmemAliasing); + LIB_FUNCTION("v4V7yvdU9zo", "libkernel", 1, "libkernel", 1, 1, sceKernelEnableDmemAliasing2); + LIB_FUNCTION("vhlQXKkQFe0", "libkernel", 1, "libkernel", 1, 1, + sceKernelEnablePthreadObjectCheck); + LIB_FUNCTION("D4yla3vx4tY", "libkernel", 1, "libkernel", 1, 1, sceKernelError); + LIB_FUNCTION("c7noapHDHWU", "libkernel", 1, "libkernel", 1, 1, sceKernelEventLogInit); + LIB_FUNCTION("H6bIN2qvlxY", "libkernel", 1, "libkernel", 1, 1, sceKernelEventLogPread); + LIB_FUNCTION("L6WLBSYfL6k", "libkernel", 1, "libkernel", 1, 1, sceKernelEventLogRead); + LIB_FUNCTION("TmkVz5YgHg8", "libkernel", 1, "libkernel", 1, 1, sceKernelEventLogWrite); + LIB_FUNCTION("UtszJWHrDcA", "libkernel", 1, "libkernel", 1, 1, sceKernelFchmod); + LIB_FUNCTION("SoZkxZkCHaw", "libkernel", 1, "libkernel", 1, 1, sceKernelFcntl); + LIB_FUNCTION("30Rh4ixbKy4", "libkernel", 1, "libkernel", 1, 1, sceKernelFdatasync); + LIB_FUNCTION("YDg-SQj66AQ", "libkernel", 1, "libkernel", 1, 1, sceKernelFlock); + LIB_FUNCTION("kBwCPsYX-m4", "libkernel", 1, "libkernel", 1, 1, sceKernelFstat); + LIB_FUNCTION("fTx66l5iWIA", "libkernel", 1, "libkernel", 1, 1, sceKernelFsync); + LIB_FUNCTION("VW3TVZiM4-E", "libkernel", 1, "libkernel", 1, 1, sceKernelFtruncate); + LIB_FUNCTION("NLq2b1jOaN0", "libkernel", 1, "libkernel", 1, 1, sceKernelFutimes); + LIB_FUNCTION("YeU23Szo3BM", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetAllowedSdkVersionOnSystem); + LIB_FUNCTION("G-MYv5erXaU", "libkernel", 1, "libkernel", 1, 1, sceKernelGetAppInfo); + LIB_FUNCTION("1UOnecNlNW0", "libkernel", 1, "libkernel", 1, 1, sceKernelGetAslrStatus); + LIB_FUNCTION("QtLhuYZf9jg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetBackupRestoreMode); + LIB_FUNCTION("CQ1bzp1ba0k", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetBackupRestoreModeOfNextBoot); + LIB_FUNCTION("wSxRrFKzKXk", "libkernel", 1, "libkernel", 1, 1, sceKernelGetBasicProductShape); + LIB_FUNCTION("tFD04DtJY+g", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetBetaUpdateTestForRcmgr); + LIB_FUNCTION("n0FvTzIPodM", "libkernel", 1, "libkernel", 1, 1, sceKernelGetBioUsageAll); + LIB_FUNCTION("oYr9L7WSCww", "libkernel", 1, "libkernel", 1, 1, sceKernelGetBootReqNotifyCount); + LIB_FUNCTION("ikkTGg4Cshw", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCallRecord); + LIB_FUNCTION("WB66evu8bsU", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCompiledSdkVersion); + LIB_FUNCTION("jgYD8N1DILg", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetCompiledSdkVersionByPath); + LIB_FUNCTION("8BrtU9maWG4", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetCompiledSdkVersionByPid); + LIB_FUNCTION("iUohlUDiGac", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuFrequency); + LIB_FUNCTION("VOx8NGmHXTs", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpumode); + LIB_FUNCTION("F9LZ1EbJnfo", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpumodeGame); + LIB_FUNCTION("qiL4fFObAxM", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuTemperature); + LIB_FUNCTION("ssmH9nMYO4o", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuUsage); + LIB_FUNCTION("ToISj0q68Qg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuUsageAll); + LIB_FUNCTION("VS45LnNqyCo", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuUsageProc); + LIB_FUNCTION("QbdkmhQQfIM", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuUsageProc2); + LIB_FUNCTION("XkEs5rH1bSk", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCpuUsageThread); + LIB_FUNCTION("g0VTBxfJyu0", "libkernel", 1, "libkernel", 1, 1, sceKernelGetCurrentCpu); + LIB_FUNCTION("i-H8tE6wTqI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetDataTransferMode); + LIB_FUNCTION("JVYt1hlHSvo", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetDebugMenuMiniModeForRcmgr); + LIB_FUNCTION("qYwuXe0hTHs", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetDebugMenuModeForPsmForRcmgr); + LIB_FUNCTION("opMiSfTJyJo", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetDebugMenuModeForRcmgr); + LIB_FUNCTION("j2AIqSqJP0w", "libkernel", 1, "libkernel", 1, 1, sceKernelGetdents); + LIB_FUNCTION("pO96TwzOm5E", "libkernel", 1, "libkernel", 1, 1, sceKernelGetDirectMemorySize); + LIB_FUNCTION("BC+OG5m9+bw", "libkernel", 1, "libkernel", 1, 1, sceKernelGetDirectMemoryType); + LIB_FUNCTION("taRWhTJFTgE", "libkernel", 1, "libkernel", 1, 1, sceKernelGetdirentries); + LIB_FUNCTION("kwGyyjohI50", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventData); + LIB_FUNCTION("Uu-iDFC9aUc", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventError); + LIB_FUNCTION("Q0qr9AyqJSk", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventFflags); + LIB_FUNCTION("23CPPI1tyBY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventFilter); + LIB_FUNCTION("mJ7aghmgvfc", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventId); + LIB_FUNCTION("vz+pg2zdopI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetEventUserData); + LIB_FUNCTION("wJABa1X4+ec", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetExecutableModuleHandle); + LIB_FUNCTION("OA7xpGDL8sY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetExtLibcHandle); + LIB_FUNCTION("cVC4JXxpb-s", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetFakeFinalizeMenuForRcmgr); + LIB_FUNCTION("LJVcP+0wRIk", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetFlagedUpdaterForRcmgr); + LIB_FUNCTION("we5t5V4Fc70", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetForceUpdateModeForRcmgr); + LIB_FUNCTION("JGfTMBOdUJo", "libkernel", 1, "libkernel", 1, 1, sceKernelGetFsSandboxRandomWord); + LIB_FUNCTION("4oXYe9Xmk0Q", "libkernel", 1, "libkernel", 1, 1, sceKernelGetGPI); + LIB_FUNCTION("6sy3Y9QjOJw", "libkernel", 1, "libkernel", 1, 1, sceKernelGetGPO); + LIB_FUNCTION("ZTJiZPZvNk4", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetHwFeatureInfoForDecid); + LIB_FUNCTION("lZG-WlKxRqQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetIdPs); + LIB_FUNCTION("2YsHtbvCrgs", "libkernel", 1, "libkernel", 1, 1, sceKernelGetIdTableCurrentCount); + LIB_FUNCTION("ePRSOZsroIQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetIpcPath); + LIB_FUNCTION("AmJ0mn2l4lM", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetLibkernelTextLocation); + LIB_FUNCTION("0vTn5IDMU9A", "libkernel", 1, "libkernel", 1, 1, sceKernelGetMainSocId); + LIB_FUNCTION("kUpgrXIrz7Q", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleInfo); + LIB_FUNCTION("RpQJJVKTiFM", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleInfoForUnwind); + LIB_FUNCTION("f7KBOafysXo", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleInfoFromAddr); + LIB_FUNCTION("HZO7xOos4xc", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleInfoInternal); + LIB_FUNCTION("IuxnUuXk6Bg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleList); + LIB_FUNCTION("u+mlUkWpU3Y", "libkernel", 1, "libkernel", 1, 1, sceKernelGetModuleListInternal); + LIB_FUNCTION("ul57hvm6mBc", "libkernel", 1, "libkernel", 1, 1, sceKernelGetOpenPsIdForSystem); + LIB_FUNCTION("tZ2yplY8MBY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetPageTableStats); + LIB_FUNCTION("NSw6bEcrtWo", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetPagingStatsOfAllObjects); + LIB_FUNCTION("7hsMq4oz0Sc", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetPagingStatsOfAllThreads); + LIB_FUNCTION("Zzxstsom9-w", "libkernel", 1, "libkernel", 1, 1, sceKernelGetPhysPageSize); + LIB_FUNCTION("fUJRLEbJOuQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessName); + LIB_FUNCTION("4J2sUJmuHZQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTime); + LIB_FUNCTION("fgxnMeTNUtY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTimeCounter); + LIB_FUNCTION("BNowx2l588E", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetProcessTimeCounterFrequency); + LIB_FUNCTION("+g+UP8Pyfmo", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessType); + LIB_FUNCTION("959qrazPIrg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcParam); + LIB_FUNCTION("pyAyDVpDOhw", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProductCode); + LIB_FUNCTION("tlLu+KqzgDY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProductStr); + LIB_FUNCTION("L0v2Go5jOuM", "libkernel", 1, "libkernel", 1, 1, sceKernelGetPrtAperture); + LIB_FUNCTION("C2ltEJILIGE", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetPsmIntdevModeForRcmgr); + LIB_FUNCTION("ZotSeVujZaU", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetPsnAccessTraceLogForRcmgr); + LIB_FUNCTION("58GfHBfwpOY", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetQafExpirationTimeNotafterForRcmgr); + LIB_FUNCTION("QZ3WWIhtNbE", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetQafExpirationTimeNotbeforeForRcmgr); + LIB_FUNCTION("H0hj8V6fJwk", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetQafGenerationForRcmgr); + LIB_FUNCTION("qJnZcaDrZvI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetQafNameForRcmgr); + LIB_FUNCTION("9thKyBzyAR4", "libkernel", 1, "libkernel", 1, 1, sceKernelGetRenderingMode); + LIB_FUNCTION("Q30w46WtYQw", "libkernel", 1, "libkernel", 1, 1, sceKernelGetResidentCount); + LIB_FUNCTION("a7DM+5cDkAg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetResidentFmemCount); + LIB_FUNCTION("bmQaivctXo4", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSafemode); + LIB_FUNCTION("bt0POEUZddE", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetSanitizerMallocReplace); + LIB_FUNCTION("py6L8jiVAN8", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetSanitizerMallocReplaceExternal); + LIB_FUNCTION("F4Kib3Mb0wI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSanitizerNewReplace); + LIB_FUNCTION("bnZxYgAFeA0", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetSanitizerNewReplaceExternal); + LIB_FUNCTION("CA5jcDb2vYI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSocPowerConsumption); + LIB_FUNCTION("zzKyvoELf4I", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetSocSensorTemperature); + LIB_FUNCTION("3KIbxxVQv84", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSpecialIForRcmgr); + LIB_FUNCTION("ou2GyAJwJ+Q", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSubsysId); + LIB_FUNCTION("mpbGISNJ6go", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSystemExVersion); + LIB_FUNCTION("fFMg-cBHBBY", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetSystemLevelDebuggerModeForRcmgr); + LIB_FUNCTION("3EDFoWECKOg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSystemSwBeta); + LIB_FUNCTION("Mv1zUObHvXI", "libkernel", 1, "libkernel", 1, 1, sceKernelGetSystemSwVersion); + LIB_FUNCTION("4vkZwDJbMx0", "libkernel", 1, "libkernel", 1, 1, sceKernelGetThreadName); + LIB_FUNCTION("ejekcaNQNq0", "libkernel", 1, "libkernel", 1, 1, sceKernelGettimeofday); + LIB_FUNCTION("kOcnerypnQA", "libkernel", 1, "libkernel", 1, 1, sceKernelGettimezone); + LIB_FUNCTION("Od0uMJZoVWg", "libkernel", 1, "libkernel", 1, 1, sceKernelGetTraceMemoryStats); + LIB_FUNCTION("1j3S3n-tTW4", "libkernel", 1, "libkernel", 1, 1, sceKernelGetTscFrequency); + LIB_FUNCTION("ToKKfC8tKIk", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenDataExecutionForRcmgr); + LIB_FUNCTION("8PGQdZFioFQ", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenExpirationTimeNotafterForRcmgr); + LIB_FUNCTION("Htwoe5tvNYg", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenExpirationTimeNotbeforeForRcmgr); + LIB_FUNCTION("MaCKSOQDtyU", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenFakeSharefactoryForRcmgr); + LIB_FUNCTION("0yVJNcMqyXk", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenFlagedUpdaterForRcmgr); + LIB_FUNCTION("+XuZD9HV0p4", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenNpEnvSwitchingForRcmgr); + LIB_FUNCTION("VbrTamW6dJs", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenSaveDataRepairForRcmgr); + LIB_FUNCTION("0NyJTCJWuuk", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenStoreModeForRcmgr); + LIB_FUNCTION("b0cryxaTM4k", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenUseSoftwagnerForAcmgr); + LIB_FUNCTION("Vo1qeT4JY6I", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenUseSoftwagnerForRcmgr); + LIB_FUNCTION("T1t68JwPqME", "libkernel", 1, "libkernel", 1, 1, + sceKernelGetUtokenWeakenedPortRestrictionForRcmgr); + LIB_FUNCTION("heiOpxS1Zio", "libkernel", 1, "libkernel", 1, 1, sceKernelGetVrCaptureSize); + LIB_FUNCTION("rNRtm1uioyY", "libkernel", 1, "libkernel", 1, 1, sceKernelHasNeoMode); + LIB_FUNCTION("l-zbaxNzruE", "libkernel", 1, "libkernel", 1, 1, sceKernelHwHasOpticalOut); + LIB_FUNCTION("+ofrEv1aAU0", "libkernel", 1, "libkernel", 1, 1, sceKernelHwHasWlanBt); + LIB_FUNCTION("1wxFFk3xIhA", "libkernel", 1, "libkernel", 1, 1, sceKernelIccControlBDPowerState); + LIB_FUNCTION("ZqxPUMisNkY", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccControlUSBPowerState); + LIB_FUNCTION("zLEuSU+hl-w", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetBDPowerState); + LIB_FUNCTION("U0NKl-rjhYA", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetCountTime); + LIB_FUNCTION("1NlbNxWzn7U", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetCPMode); + LIB_FUNCTION("Z7NoR9m5SVo", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetCpuInfoBit); + LIB_FUNCTION("8TqMzIggthc", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetErrLog); + LIB_FUNCTION("C+i9gJY4A1I", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetHwInfo); + LIB_FUNCTION("tCQzG0iC8zw", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccGetPowerNumberOfBootShutdown); + LIB_FUNCTION("PA6ZwQM5tNQ", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccGetPowerOperatingTime); + LIB_FUNCTION("wXmx+vN8puE", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetPowerUpCause); + LIB_FUNCTION("L21PBFwqIiM", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetSysEventLog); + LIB_FUNCTION("zEmi6zvei2k", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetThermalAlert); + LIB_FUNCTION("NtOA+0RApBg", "libkernel", 1, "libkernel", 1, 1, sceKernelIccGetUSBPowerState); + LIB_FUNCTION("qWoGe2XqwVw", "libkernel", 1, "libkernel", 1, 1, sceKernelIccIndicatorBootDone); + LIB_FUNCTION("gQXxz1IoL5U", "libkernel", 1, "libkernel", 1, 1, sceKernelIccIndicatorShutdown); + LIB_FUNCTION("98LV9dS2Fvw", "libkernel", 1, "libkernel", 1, 1, sceKernelIccIndicatorStandby); + LIB_FUNCTION("7Q-U-8yN1Hk", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccIndicatorStandbyBoot); + LIB_FUNCTION("Eye1lgCj9yo", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccIndicatorStandbyShutdown); + LIB_FUNCTION("wNeGsNes5ck", "libkernel", 1, "libkernel", 1, 1, sceKernelIccNotifyBootStatus); + LIB_FUNCTION("xXj0rnNUYIk", "libkernel", 1, "libkernel", 1, 1, sceKernelIccNvsFlush); + LIB_FUNCTION("0gkGdPk8dXw", "libkernel", 1, "libkernel", 1, 1, + sceKernelIccReadPowerBootMessage); + LIB_FUNCTION("iBQ2omlTuls", "libkernel", 1, "libkernel", 1, 1, sceKernelIccSetBuzzer); + LIB_FUNCTION("hc0GFWwSrR4", "libkernel", 1, "libkernel", 1, 1, sceKernelIccSetCPMode); + LIB_FUNCTION("RP9ImTNDfP8", "libkernel", 1, "libkernel", 1, 1, sceKernelIccSetCpuInfoBit); + LIB_FUNCTION("o4NI2wpFhbI", "libkernel", 1, "libkernel", 1, 1, sceKernelIccSetDownloadMode); + LIB_FUNCTION("WkwEd3N7w0Y", "libkernel", 1, "libkernel", 1, 1, + sceKernelInstallExceptionHandler); + LIB_FUNCTION("L7aj7caj8+s", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalGetKmemStatistics); + LIB_FUNCTION("n2nyhRL5uUg", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalGetMapStatistics); + LIB_FUNCTION("rb8JKArrzc0", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalHeapPrintBacktraceWithModuleInfo); + LIB_FUNCTION("xAKAe6kFk90", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalMapDirectMemory); + LIB_FUNCTION("0ttVHjPWLsE", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalMapNamedDirectMemory); + LIB_FUNCTION("rjEuM0nb8xg", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalMemoryGetAvailableSize); + LIB_FUNCTION("-YTW+qXc3CQ", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalMemoryGetModuleSegmentInfo); + LIB_FUNCTION("1vCEy8EP+gc", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalResumeDirectMemoryRelease); + LIB_FUNCTION("3+E-5EFZxDo", "libkernel", 1, "libkernel", 1, 1, + sceKernelInternalSuspendDirectMemoryRelease); + LIB_FUNCTION("jh+8XiK4LeE", "libkernel", 1, "libkernel", 1, 1, + sceKernelIsAddressSanitizerEnabled); + LIB_FUNCTION("oU4h4oBe2l0", "libkernel", 1, "libkernel", 1, 1, + sceKernelIsAllowedToSelectDvdRegion); + LIB_FUNCTION("cbn9Di01j0k", "libkernel", 1, "libkernel", 1, 1, sceKernelIsAuthenticNeo); + LIB_FUNCTION("8aCOCGoRkUI", "libkernel", 1, "libkernel", 1, 1, sceKernelIsCEX); + LIB_FUNCTION("K0ZTCJ-wFrM", "libkernel", 1, "libkernel", 1, 1, sceKernelIsDebuggerAttached); + LIB_FUNCTION("QNjGUdj1HPM", "libkernel", 1, "libkernel", 1, 1, sceKernelIsDevKit); + LIB_FUNCTION("B1K98ubk6V8", "libkernel", 1, "libkernel", 1, 1, sceKernelIsExperimentalBeta); + LIB_FUNCTION("ts25M0mp2uY", "libkernel", 1, "libkernel", 1, 1, sceKernelIsGenuineCEX); + LIB_FUNCTION("lFf3UU811v4", "libkernel", 1, "libkernel", 1, 1, sceKernelIsGenuineDevKit); + LIB_FUNCTION("H54cSDvjryI", "libkernel", 1, "libkernel", 1, 1, sceKernelIsGenuineKratosCex); + LIB_FUNCTION("u3h77G+tFVc", "libkernel", 1, "libkernel", 1, 1, sceKernelIsGenuineN); + LIB_FUNCTION("S4XWKGFp+bc", "libkernel", 1, "libkernel", 1, 1, sceKernelIsGenuineTestKit); + LIB_FUNCTION("xeu-pV8wkKs", "libkernel", 1, "libkernel", 1, 1, sceKernelIsInSandbox); + LIB_FUNCTION("miPa6vSAqos", "libkernel", 1, "libkernel", 1, 1, sceKernelIsKratos); + LIB_FUNCTION("Jp76d0USJeM", "libkernel", 1, "libkernel", 1, 1, sceKernelIsMainOnStanbyMode); + LIB_FUNCTION("vZser6ysSbM", "libkernel", 1, "libkernel", 1, 1, sceKernelIsMainOnStandbyMode); + LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, sceKernelIsNeoMode); + LIB_FUNCTION("yDBwVAolDgg", "libkernel", 1, "libkernel", 1, 1, sceKernelIsStack); + LIB_FUNCTION("1CVP7E-WFKk", "libkernel", 1, "libkernel", 1, 1, sceKernelIsTestKit); + LIB_FUNCTION("MR221Mwo0Pc", "libkernel", 1, "libkernel", 1, 1, + sceKernelJitCreateAliasOfSharedMemory); + LIB_FUNCTION("avvJ3J0H0EY", "libkernel", 1, "libkernel", 1, 1, sceKernelJitCreateSharedMemory); + LIB_FUNCTION("9yxlvURJU6U", "libkernel", 1, "libkernel", 1, 1, sceKernelJitGetSharedMemoryInfo); + LIB_FUNCTION("YKT49TOLQWs", "libkernel", 1, "libkernel", 1, 1, sceKernelJitMapSharedMemory); + LIB_FUNCTION("m5zDvD-LLjo", "libkernel", 1, "libkernel", 1, 1, sceKernelKernelHeapUsage); + LIB_FUNCTION("wzvqT4UqKX8", "libkernel", 1, "libkernel", 1, 1, sceKernelLoadStartModule); + LIB_FUNCTION("Gg3+yWL6DWU", "libkernel", 1, "libkernel", 1, 1, + sceKernelLoadStartModuleForSysmodule); + LIB_FUNCTION("oib76F-12fk", "libkernel", 1, "libkernel", 1, 1, sceKernelLseek); + LIB_FUNCTION("LFbwY8r50o8", "libkernel", 1, "libkernel", 1, 1, sceKernelLwfsAllocateBlock); + LIB_FUNCTION("s2PjRq4By9U", "libkernel", 1, "libkernel", 1, 1, sceKernelLwfsLseek); + LIB_FUNCTION("T4osaR3EDkI", "libkernel", 1, "libkernel", 1, 1, sceKernelLwfsSetAttribute); + LIB_FUNCTION("kHOS+St2y7M", "libkernel", 1, "libkernel", 1, 1, sceKernelLwfsTrimBlock); + LIB_FUNCTION("FNigDX9ue0g", "libkernel", 1, "libkernel", 1, 1, sceKernelLwfsWrite); + LIB_FUNCTION("L-Q3LEjIbgA", "libkernel", 1, "libkernel", 1, 1, sceKernelMapDirectMemory); + LIB_FUNCTION("BQQniolj9tQ", "libkernel", 1, "libkernel", 1, 1, sceKernelMapDirectMemory2); + LIB_FUNCTION("IWIBBdTHit4", "libkernel", 1, "libkernel", 1, 1, sceKernelMapFlexibleMemory); + LIB_FUNCTION("NcaWUxfMNIQ", "libkernel", 1, "libkernel", 1, 1, sceKernelMapNamedDirectMemory); + LIB_FUNCTION("mL8NDH86iQI", "libkernel", 1, "libkernel", 1, 1, sceKernelMapNamedFlexibleMemory); + LIB_FUNCTION("kc+LEEIYakc", "libkernel", 1, "libkernel", 1, 1, + sceKernelMapNamedSystemFlexibleMemory); + LIB_FUNCTION("8cAlCzoOiic", "libkernel", 1, "libkernel", 1, 1, + sceKernelMapSanitizerShadowMemory); + LIB_FUNCTION("DpDnfM6StzA", "libkernel", 1, "libkernel", 1, 1, sceKernelMapTraceMemory); + LIB_FUNCTION("YN878uKRBbE", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolBatch); + LIB_FUNCTION("Vzl66WmfLvk", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolCommit); + LIB_FUNCTION("LXo1tpFqJGs", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolDecommit); + LIB_FUNCTION("qCSfqDILlns", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolExpand); + LIB_FUNCTION("bvD+95Q6asU", "libkernel", 1, "libkernel", 1, 1, + sceKernelMemoryPoolGetBlockStats); + LIB_FUNCTION("e1GIcX4AlY4", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolMove); + LIB_FUNCTION("pU-QydtGcGY", "libkernel", 1, "libkernel", 1, 1, sceKernelMemoryPoolReserve); + LIB_FUNCTION("1-LFLmRFxxM", "libkernel", 1, "libkernel", 1, 1, sceKernelMkdir); + LIB_FUNCTION("3k6kx-zOOSQ", "libkernel", 1, "libkernel", 1, 1, sceKernelMlock); + LIB_FUNCTION("EfqmKkirJF0", "libkernel", 1, "libkernel", 1, 1, sceKernelMlockall); + LIB_FUNCTION("PGhQHd-dzv8", "libkernel", 1, "libkernel", 1, 1, sceKernelMmap); + LIB_FUNCTION("vSMAm3cxYTY", "libkernel", 1, "libkernel", 1, 1, sceKernelMprotect); + LIB_FUNCTION("DkNebxmJyVI", "libkernel", 1, "libkernel", 1, 1, sceKernelMsync); + LIB_FUNCTION("9bfdLIyuwCY", "libkernel", 1, "libkernel", 1, 1, sceKernelMtypeprotect); + LIB_FUNCTION("xQIIfJ860sk", "libkernel", 1, "libkernel", 1, 1, sceKernelMunlock); + LIB_FUNCTION("lvD71jP2Mnk", "libkernel", 1, "libkernel", 1, 1, sceKernelMunlockall); + LIB_FUNCTION("cQke9UuBQOk", "libkernel", 1, "libkernel", 1, 1, sceKernelMunmap); + LIB_FUNCTION("QvsZxomvUHs", "libkernel", 1, "libkernel", 1, 1, sceKernelNanosleep); + LIB_FUNCTION("KB7Vc2+5S54", "libkernel", 1, "libkernel", 1, 1, sceKernelNormalizePath); + LIB_FUNCTION("2z1Tkrqh8jE", "libkernel", 1, "libkernel", 1, 1, sceKernelNotifyAppStateChanged); + LIB_FUNCTION("hjErHT1CwJM", "libkernel", 1, "libkernel", 1, 1, + sceKernelNotifySystemSuspendResumeProgress); + LIB_FUNCTION("da6-yq0GbLg", "libkernel", 1, "libkernel", 1, 1, + sceKernelNotifySystemSuspendStart); + LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen); + LIB_FUNCTION("wibWed78GyY", "libkernel", 1, "libkernel", 1, 1, sceKernelOpenEport); + LIB_FUNCTION("1vDaenmJtyA", "libkernel", 1, "libkernel", 1, 1, sceKernelOpenEventFlag); + LIB_FUNCTION("MwhHNKdBXq8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpenSema); + LIB_FUNCTION("9lvj5DjHZiA", "libkernel", 1, "libkernel", 1, 1, sceKernelPollEventFlag); + LIB_FUNCTION("12wOHk8ywb0", "libkernel", 1, "libkernel", 1, 1, sceKernelPollSema); + LIB_FUNCTION("+r3rMFwItV4", "libkernel", 1, "libkernel", 1, 1, sceKernelPread); + LIB_FUNCTION("yTj62I7kw4s", "libkernel", 1, "libkernel", 1, 1, sceKernelPreadv); + LIB_FUNCTION("Wl2o5hOVZdw", "libkernel", 1, "libkernel", 1, 1, + sceKernelPrintBacktraceWithModuleInfo); + LIB_FUNCTION("k1jIkFHa9OU", "libkernel", 1, "libkernel", 1, 1, sceKernelProtectDirectMemory); + LIB_FUNCTION("cBp0Ad-24LA", "libkernel", 1, "libkernel", 1, 1, + sceKernelProtectDirectMemoryForPID); + LIB_FUNCTION("nKWi-N2HBV4", "libkernel", 1, "libkernel", 1, 1, sceKernelPwrite); + LIB_FUNCTION("mBd4AfLP+u8", "libkernel", 1, "libkernel", 1, 1, sceKernelPwritev); + LIB_FUNCTION("WFcfL2lzido", "libkernel", 1, "libkernel", 1, 1, sceKernelQueryMemoryProtection); + LIB_FUNCTION("+8GCeq43o7c", "libkernel", 1, "libkernel", 1, 1, sceKernelQueryTraceMemory); + LIB_FUNCTION("il03nluKfMk", "libkernel", 1, "libkernel", 1, 1, sceKernelRaiseException); + LIB_FUNCTION("p2suRCR4KqE", "libkernel", 1, "libkernel", 1, 1, sceKernelRandomizedPath); + LIB_FUNCTION("LxIacrWiJ3w", "libkernel", 1, "libkernel", 1, 1, sceKernelRdup); + LIB_FUNCTION("Cg4srZ6TKbU", "libkernel", 1, "libkernel", 1, 1, sceKernelRead); + LIB_FUNCTION("-2IRUCO--PM", "libkernel", 1, "libkernel", 1, 1, sceKernelReadTsc); + LIB_FUNCTION("QqxBetgJH+g", "libkernel", 1, "libkernel", 1, 1, sceKernelReadv); + LIB_FUNCTION("bXxVDD3VuWc", "libkernel", 1, "libkernel", 1, 1, sceKernelReboot); + LIB_FUNCTION("MBuItvba6z8", "libkernel", 1, "libkernel", 1, 1, sceKernelReleaseDirectMemory); + LIB_FUNCTION("teiItL2boFw", "libkernel", 1, "libkernel", 1, 1, sceKernelReleaseFlexibleMemory); + LIB_FUNCTION("Alqa9RE0Y5k", "libkernel", 1, "libkernel", 1, 1, + sceKernelReleaseTraceDirectMemory); + LIB_FUNCTION("Qhv5ARAoOEc", "libkernel", 1, "libkernel", 1, 1, sceKernelRemoveExceptionHandler); + LIB_FUNCTION("52NcYU9+lEo", "libkernel", 1, "libkernel", 1, 1, sceKernelRename); + LIB_FUNCTION("M0z6Dr6TNnM", "libkernel", 1, "libkernel", 1, 1, + sceKernelReportUnpatchedFunctionCall); + LIB_FUNCTION("VjWR6g9qL2k", "libkernel", 1, "libkernel", 1, 1, sceKernelReserve2mbPage); + LIB_FUNCTION("4zUh1kGuaiw", "libkernel", 1, "libkernel", 1, 1, + sceKernelReserveSystemDirectMemory); + LIB_FUNCTION("7oxv3PPCumo", "libkernel", 1, "libkernel", 1, 1, sceKernelReserveVirtualRange); + LIB_FUNCTION("PS5hxxGEVB8", "libkernel", 1, "libkernel", 1, 1, + sceKernelResumeDirectMemoryRelease); + LIB_FUNCTION("naInUjYt3so", "libkernel", 1, "libkernel", 1, 1, sceKernelRmdir); + LIB_FUNCTION("Kf10sqhOoRY", "libkernel", 1, "libkernel", 1, 1, sceKernelRtldControl); + LIB_FUNCTION("ASVb7Y-pR4Y", "libkernel", 1, "libkernel", 1, 1, sceKernelSandboxPath); + LIB_FUNCTION("zl7hupSO0C0", "libkernel", 1, "libkernel", 1, 1, + sceKernelSendNotificationRequest); + LIB_FUNCTION("CkomU+GYCQ8", "libkernel", 1, "libkernel", 1, 1, sceKernelSetAppInfo); + LIB_FUNCTION("9xRIkqnNibE", "libkernel", 1, "libkernel", 1, 1, sceKernelSetBackupRestoreMode); + LIB_FUNCTION("V0ey5Vz5F7k", "libkernel", 1, "libkernel", 1, 1, sceKernelSetBaseModeClock); + LIB_FUNCTION("WS7uPTZ0WCs", "libkernel", 1, "libkernel", 1, 1, sceKernelSetBesteffort); + LIB_FUNCTION("c8J3uxxQTl4", "libkernel", 1, "libkernel", 1, 1, sceKernelSetBootReqNotify); + LIB_FUNCTION("P6dUEXUHXjo", "libkernel", 1, "libkernel", 1, 1, sceKernelSetCallRecord); + LIB_FUNCTION("FeBOnMEm0SY", "libkernel", 1, "libkernel", 1, 1, + sceKernelSetCompressionAttribute); + LIB_FUNCTION("KCwXUKT269I", "libkernel", 1, "libkernel", 1, 1, sceKernelSetCpumodeGame); + LIB_FUNCTION("+rSNKzU+aNQ", "libkernel", 1, "libkernel", 1, 1, sceKernelSetDataTransferMode); + LIB_FUNCTION("IOnSvHzqu6A", "libkernel", 1, "libkernel", 1, 1, sceKernelSetEventFlag); + LIB_FUNCTION("VjBtg5Btl94", "libkernel", 1, "libkernel", 1, 1, sceKernelSetFsstParam); + LIB_FUNCTION("ej7DGZDhuAk", "libkernel", 1, "libkernel", 1, 1, + sceKernelSetGameDirectMemoryLimit); + LIB_FUNCTION("rzEsC81gurc", "libkernel", 1, "libkernel", 1, 1, sceKernelSetGPI); + LIB_FUNCTION("ca7v6Cxulzs", "libkernel", 1, "libkernel", 1, 1, sceKernelSetGPO); + LIB_FUNCTION("4nAp4pZgV1A", "libkernel", 1, "libkernel", 1, 1, sceKernelSetGpuCu); + LIB_FUNCTION("A1zOC17L80g", "libkernel", 1, "libkernel", 1, 1, sceKernelSetMemoryPstate); + LIB_FUNCTION("EA4bmgm02o8", "libkernel", 1, "libkernel", 1, 1, sceKernelSetNeoModeClock); + LIB_FUNCTION("BDLSyH7y6Mo", "libkernel", 1, "libkernel", 1, 1, sceKernelSetPhysFmemLimit); + LIB_FUNCTION("8UVYwy0F2Hk", "libkernel", 1, "libkernel", 1, 1, sceKernelSetProcessName); + LIB_FUNCTION("-W4xI5aVI8w", "libkernel", 1, "libkernel", 1, 1, sceKernelSetProcessProperty); + LIB_FUNCTION("U5HG6wD4smU", "libkernel", 1, "libkernel", 1, 1, + sceKernelSetProcessPropertyString); + LIB_FUNCTION("BohYr-F7-is", "libkernel", 1, "libkernel", 1, 1, sceKernelSetPrtAperture); + LIB_FUNCTION("As-JdqyUuMs", "libkernel", 1, "libkernel", 1, 1, sceKernelSetSafemode); + LIB_FUNCTION("ChCOChPU-YM", "libkernel", 1, "libkernel", 1, 1, sceKernelSettimeofday); + LIB_FUNCTION("cxdklXtQcqA", "libkernel", 1, "libkernel", 1, 1, sceKernelSetTimezoneInfo); + LIB_FUNCTION("DGMG3JshrZU", "libkernel", 1, "libkernel", 1, 1, sceKernelSetVirtualRangeName); + LIB_FUNCTION("R7Xj-th93gs", "libkernel", 1, "libkernel", 1, 1, sceKernelSetVmContainer); + LIB_FUNCTION("4czppHBiriw", "libkernel", 1, "libkernel", 1, 1, sceKernelSignalSema); + LIB_FUNCTION("-ZR+hG7aDHw", "libkernel", 1, "libkernel", 1, 1, sceKernelSleep); + LIB_FUNCTION("8KDMful7g1Y", "libkernel", 1, "libkernel", 1, 1, sceKernelSlvNotifyError); + LIB_FUNCTION("eV9wAD2riIA", "libkernel", 1, "libkernel", 1, 1, sceKernelStat); + LIB_FUNCTION("QKd0qM58Qes", "libkernel", 1, "libkernel", 1, 1, sceKernelStopUnloadModule); + LIB_FUNCTION("C8wi8QOUQQk", "libkernel", 1, "libkernel", 1, 1, + sceKernelSuspendDirectMemoryRelease); + LIB_FUNCTION("KK6B72YC-js", "libkernel", 1, "libkernel", 1, 1, sceKernelSwitchToBaseMode); + LIB_FUNCTION("+DVcq4YF6Xg", "libkernel", 1, "libkernel", 1, 1, sceKernelSwitchToNeoMode); + LIB_FUNCTION("uvT2iYBBnkY", "libkernel", 1, "libkernel", 1, 1, sceKernelSync); + LIB_FUNCTION("hUN72ocX6gM", "libkernel", 1, "libkernel", 1, 1, sceKernelTerminateSysCore); + LIB_FUNCTION("1yca4VvfcNA", "libkernel", 1, "libkernel", 1, 1, + sceKernelTitleWorkaroundIsEnabled); + LIB_FUNCTION("GST42pfUfMc", "libkernel", 1, "libkernel", 1, 1, + sceKernelTitleWorkdaroundIsEnabled); + LIB_FUNCTION("eESTogkCMPE", "libkernel", 1, "libkernel", 1, 1, sceKernelTraceMemoryTypeProtect); + LIB_FUNCTION("is-XQhYPRaQ", "libkernel", 1, "libkernel", 1, 1, sceKernelTriggerEport); + LIB_FUNCTION("F6e0kwo4cnk", "libkernel", 1, "libkernel", 1, 1, sceKernelTriggerUserEvent); + LIB_FUNCTION("WlyEA-sLDf0", "libkernel", 1, "libkernel", 1, 1, sceKernelTruncate); + LIB_FUNCTION("AUXVxWeJU-A", "libkernel", 1, "libkernel", 1, 1, sceKernelUnlink); + LIB_FUNCTION("1jfXLRVzisc", "libkernel", 1, "libkernel", 1, 1, sceKernelUsleep); + LIB_FUNCTION("0Cq8ipKr9n0", "libkernel", 1, "libkernel", 1, 1, sceKernelUtimes); + LIB_FUNCTION("Xjoosiw+XPI", "libkernel", 1, "libkernel", 1, 1, sceKernelUuidCreate); + LIB_FUNCTION("rVjRvHJ0X6c", "libkernel", 1, "libkernel", 1, 1, sceKernelVirtualQuery); + LIB_FUNCTION("f77qlxIbqu0", "libkernel", 1, "libkernel", 1, 1, sceKernelVirtualQueryAll); + LIB_FUNCTION("fzyMKs9kim0", "libkernel", 1, "libkernel", 1, 1, sceKernelWaitEqueue); + LIB_FUNCTION("JTvBflhYazQ", "libkernel", 1, "libkernel", 1, 1, sceKernelWaitEventFlag); + LIB_FUNCTION("Zxa0VhQVTsk", "libkernel", 1, "libkernel", 1, 1, sceKernelWaitSema); + LIB_FUNCTION("4wSze92BhLI", "libkernel", 1, "libkernel", 1, 1, sceKernelWrite); + LIB_FUNCTION("I111PPn2g18", "libkernel", 1, "libkernel", 1, 1, sceKernelWriteSdkEventLog); + LIB_FUNCTION("kAt6VDbHmro", "libkernel", 1, "libkernel", 1, 1, sceKernelWritev); + LIB_FUNCTION("BtJ3gH33xss", "libkernel", 1, "libkernel", 1, 1, sceKernelYieldCpumode); + LIB_FUNCTION("pi90NsG3zPA", "libkernel", 1, "libkernel", 1, 1, sceLibcMspaceCreateForMonoMutex); + LIB_FUNCTION("i1kREW2pchs", "libkernel", 1, "libkernel", 1, 1, scePthreadAtfork); + LIB_FUNCTION("62KCwEMmzcM", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrDestroy); + LIB_FUNCTION("x1X76arYMxU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGet); + LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity); + LIB_FUNCTION("JaRMy+QcpeU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetdetachstate); + LIB_FUNCTION("txHtngJ+eyc", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetguardsize); + LIB_FUNCTION("lpMP8HhkBbg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetinheritsched); + LIB_FUNCTION("FXPWHNk8Of0", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetschedparam); + LIB_FUNCTION("NMyIQ9WgWbU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetschedpolicy); + LIB_FUNCTION("+7B2AEKKns8", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetscope); + LIB_FUNCTION("-quPa4SEJUw", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetstack); + LIB_FUNCTION("Ru36fiTtJzA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetstackaddr); + LIB_FUNCTION("-fA+7ZlGDQs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetstacksize); + LIB_FUNCTION("nsYoNRywwNg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrInit); + LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity); + LIB_FUNCTION("GZSR0Ooae9Q", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetcreatesuspend); + LIB_FUNCTION("-Wreprtu0Qs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetdetachstate); + LIB_FUNCTION("El+cQ20DynU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetguardsize); + LIB_FUNCTION("eXbUSpEaTsA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetinheritsched); + LIB_FUNCTION("DzES9hQF4f4", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedparam); + LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedpolicy); + LIB_FUNCTION("YdZfEZfRnPk", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetscope); + LIB_FUNCTION("Bvn74vj6oLo", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetstack); + LIB_FUNCTION("F+yfmduIBB8", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetstackaddr); + LIB_FUNCTION("UTXzJbWhhTE", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetstacksize); + LIB_FUNCTION("oT-j4DqJHY8", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierattrDestroy); + LIB_FUNCTION("SkutDtgqJ9g", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierattrGetpshared); + LIB_FUNCTION("SDkV9xhINKI", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierattrInit); + LIB_FUNCTION("NpfpcLf5PYM", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierattrSetpshared); + LIB_FUNCTION("HudB2Jv2MPY", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierDestroy); + LIB_FUNCTION("5dgOEPsEGqw", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierInit); + LIB_FUNCTION("t9vVyTglqHQ", "libkernel", 1, "libkernel", 1, 1, scePthreadBarrierWait); + LIB_FUNCTION("qBDmpCyGssE", "libkernel", 1, "libkernel", 1, 1, scePthreadCancel); + LIB_FUNCTION("waPcxYiR3WA", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrDestroy); + LIB_FUNCTION("6qM3kO5S3Oo", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrGetclock); + LIB_FUNCTION("Dn-DRWi9t54", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrGetpshared); + LIB_FUNCTION("m5-2bsNfv7s", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrInit); + LIB_FUNCTION("c-bxj027czs", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrSetclock); + LIB_FUNCTION("6xMew9+rZwI", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrSetpshared); + LIB_FUNCTION("JGgj7Uvrl+A", "libkernel", 1, "libkernel", 1, 1, scePthreadCondBroadcast); + LIB_FUNCTION("g+PZd2hiacg", "libkernel", 1, "libkernel", 1, 1, scePthreadCondDestroy); + LIB_FUNCTION("2Tb92quprl0", "libkernel", 1, "libkernel", 1, 1, scePthreadCondInit); + LIB_FUNCTION("kDh-NfxgMtE", "libkernel", 1, "libkernel", 1, 1, scePthreadCondSignal); + LIB_FUNCTION("o69RpYO-Mu0", "libkernel", 1, "libkernel", 1, 1, scePthreadCondSignalto); + LIB_FUNCTION("BmMjYxmew1w", "libkernel", 1, "libkernel", 1, 1, scePthreadCondTimedwait); + LIB_FUNCTION("WKAXJ4XBPQ4", "libkernel", 1, "libkernel", 1, 1, scePthreadCondWait); + LIB_FUNCTION("6UgtwV+0zb4", "libkernel", 1, "libkernel", 1, 1, scePthreadCreate); + LIB_FUNCTION("4qGrR6eoP9Y", "libkernel", 1, "libkernel", 1, 1, scePthreadDetach); + LIB_FUNCTION("3PtV6p3QNX4", "libkernel", 1, "libkernel", 1, 1, scePthreadEqual); + LIB_FUNCTION("3kg7rT0NQIs", "libkernel", 1, "libkernel", 1, 1, scePthreadExit); + LIB_FUNCTION("rcrVFJsQWRY", "libkernel", 1, "libkernel", 1, 1, scePthreadGetaffinity); + LIB_FUNCTION("zLlLc3h2Prk", "libkernel", 1, "libkernel", 1, 1, scePthreadGetconcurrency); + LIB_FUNCTION("tWFPPuAJxks", "libkernel", 1, "libkernel", 1, 1, scePthreadGetcpuclockid); + LIB_FUNCTION("How7B8Oet6k", "libkernel", 1, "libkernel", 1, 1, scePthreadGetname); + LIB_FUNCTION("1tKyG7RlMJo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetprio); + LIB_FUNCTION("P41kTWUS3EI", "libkernel", 1, "libkernel", 1, 1, scePthreadGetschedparam); + LIB_FUNCTION("eoht7mQOCmo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetspecific); + LIB_FUNCTION("EI-5-jlq2dE", "libkernel", 1, "libkernel", 1, 1, scePthreadGetthreadid); + LIB_FUNCTION("onNY9Byn-W8", "libkernel", 1, "libkernel", 1, 1, scePthreadJoin); + LIB_FUNCTION("geDaqgH9lTg", "libkernel", 1, "libkernel", 1, 1, scePthreadKeyCreate); + LIB_FUNCTION("PrdHuuDekhY", "libkernel", 1, "libkernel", 1, 1, scePthreadKeyDelete); + LIB_FUNCTION("55aShElDfY4", "libkernel", 1, "libkernel", 1, 1, scePthreadMain); + LIB_FUNCTION("JVc71p0lpFs", "libkernel", 1, "libkernel", 1, 1, scePthreadMulti); + LIB_FUNCTION("smWEktiyyG0", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrDestroy); + LIB_FUNCTION("rH2mWEndluc", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrGetkind); + LIB_FUNCTION("SgjMpyH9Z9I", "libkernel", 1, "libkernel", 1, 1, + scePthreadMutexattrGetprioceiling); + LIB_FUNCTION("GoTmFeui+hQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrGetprotocol); + LIB_FUNCTION("losEubHc64c", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrGetpshared); + LIB_FUNCTION("gquEhBrS2iw", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrGettype); + LIB_FUNCTION("F8bUHwAG284", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrInit); + LIB_FUNCTION("n2MMpvU8igI", "libkernel", 1, "libkernel", 1, 1, + scePthreadMutexattrInitForInternalLibc); + LIB_FUNCTION("UWZbVSFze24", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetkind); + LIB_FUNCTION("532IaQguwMg", "libkernel", 1, "libkernel", 1, 1, + scePthreadMutexattrSetprioceiling); + LIB_FUNCTION("1FGvU0i9saQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetprotocol); + LIB_FUNCTION("mxKx9bxXF2I", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetpshared); + LIB_FUNCTION("iMp8QpE+XO4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSettype); + LIB_FUNCTION("2Of0f+3mhhE", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexDestroy); + LIB_FUNCTION("5mO+cXIAaRI", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexGetprioceiling); + LIB_FUNCTION("pOmNmyRKlIE", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexGetspinloops); + LIB_FUNCTION("AWS3NyViL9o", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexGetyieldloops); + LIB_FUNCTION("cmo1RIYva9o", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexInit); + LIB_FUNCTION("qH1gXoq71RY", "libkernel", 1, "libkernel", 1, 1, + scePthreadMutexInitForInternalLibc); + LIB_FUNCTION("W6OrTBO95UY", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexIsowned); + LIB_FUNCTION("9UK1vLZQft4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexLock); + LIB_FUNCTION("XAzZo12sbN8", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexSetprioceiling); + LIB_FUNCTION("42YkUouoMI0", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexSetspinloops); + LIB_FUNCTION("bP+cqFmBW+A", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexSetyieldloops); + LIB_FUNCTION("IafI2PxcPnQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexTimedlock); + LIB_FUNCTION("upoVrzMHFeE", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexTrylock); + LIB_FUNCTION("tn3VlD0hG60", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexUnlock); + LIB_FUNCTION("14bOACANTBo", "libkernel", 1, "libkernel", 1, 1, scePthreadOnce); + LIB_FUNCTION("GBUY7ywdULE", "libkernel", 1, "libkernel", 1, 1, scePthreadRename); + LIB_FUNCTION("DB7Mkm+Pqzw", "libkernel", 1, "libkernel", 1, 1, scePthreadResume); + LIB_FUNCTION("te+MBYMzDhY", "libkernel", 1, "libkernel", 1, 1, scePthreadResumeAll); + LIB_FUNCTION("i2ifZ3fS2fo", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrDestroy); + LIB_FUNCTION("LcOZBHGqbFk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrGetpshared); + LIB_FUNCTION("Kyls1ChFyrc", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrGettype); + LIB_FUNCTION("yOfGg-I1ZII", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrInit); + LIB_FUNCTION("-ZvQH18j10c", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrSetpshared); + LIB_FUNCTION("h-OifiouBd8", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockattrSettype); + LIB_FUNCTION("BB+kb08Tl9A", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockDestroy); + LIB_FUNCTION("6ULAa0fq4jA", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockInit); + LIB_FUNCTION("Ox9i0c7L5w0", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockRdlock); + LIB_FUNCTION("iPtZRWICjrM", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTimedrdlock); + LIB_FUNCTION("adh--6nIqTk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTimedwrlock); + LIB_FUNCTION("XD3mDeybCnk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTryrdlock); + LIB_FUNCTION("bIHoZCTomsI", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockTrywrlock); + LIB_FUNCTION("+L98PIbGttk", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockUnlock); + LIB_FUNCTION("mqdNorrB+gI", "libkernel", 1, "libkernel", 1, 1, scePthreadRwlockWrlock); + LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf); + LIB_FUNCTION("Vwc+L05e6oE", "libkernel", 1, "libkernel", 1, 1, scePthreadSemDestroy); + LIB_FUNCTION("DjpBvGlaWbQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSemGetvalue); + LIB_FUNCTION("GEnUkDZoUwY", "libkernel", 1, "libkernel", 1, 1, scePthreadSemInit); + LIB_FUNCTION("aishVAiFaYM", "libkernel", 1, "libkernel", 1, 1, scePthreadSemPost); + LIB_FUNCTION("fjN6NQHhK8k", "libkernel", 1, "libkernel", 1, 1, scePthreadSemTimedwait); + LIB_FUNCTION("H2a+IN9TP0E", "libkernel", 1, "libkernel", 1, 1, scePthreadSemTrywait); + LIB_FUNCTION("C36iRE0F5sE", "libkernel", 1, "libkernel", 1, 1, scePthreadSemWait); + LIB_FUNCTION("bt3CTBKmGyI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetaffinity); + LIB_FUNCTION("i3tB6CuvHb4", "libkernel", 1, "libkernel", 1, 1, scePthreadSetBesteffort); + LIB_FUNCTION("OAmWq+OHSjw", "libkernel", 1, "libkernel", 1, 1, scePthreadSetcancelstate); + LIB_FUNCTION("sCJd99Phct0", "libkernel", 1, "libkernel", 1, 1, scePthreadSetcanceltype); + LIB_FUNCTION("gdnv6wF6hwI", "libkernel", 1, "libkernel", 1, 1, scePthreadSetconcurrency); + LIB_FUNCTION("oVZ+-KgZJGo", "libkernel", 1, "libkernel", 1, 1, scePthreadSetDefaultstacksize); + LIB_FUNCTION("XeTqw+0Zl10", "libkernel", 1, "libkernel", 1, 1, scePthreadSetName); + LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetprio); + LIB_FUNCTION("oIRFTjoILbg", "libkernel", 1, "libkernel", 1, 1, scePthreadSetschedparam); + LIB_FUNCTION("+BzXYkqYeLE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetspecific); + LIB_FUNCTION("OTb0kHrf1pE", "libkernel", 1, "libkernel", 1, 1, scePthreadSingle); + LIB_FUNCTION("ywmONkF81ok", "libkernel", 1, "libkernel", 1, 1, scePthreadSuspend); + LIB_FUNCTION("HlzHlgqiBo8", "libkernel", 1, "libkernel", 1, 1, scePthreadSuspendAll); + LIB_FUNCTION("LapIb799SSE", "libkernel", 1, "libkernel", 1, 1, scePthreadTestcancel); + LIB_FUNCTION("HLUSF4Oi7Pc", "libkernel", 1, "libkernel", 1, 1, scePthreadTimedjoin); + LIB_FUNCTION("T72hz6ffq08", "libkernel", 1, "libkernel", 1, 1, scePthreadYield); + LIB_FUNCTION("CBNtXOoef-E", "libkernel", 1, "libkernel", 1, 1, sched_get_priority_max); + LIB_FUNCTION("m0iS6jNsXds", "libkernel", 1, "libkernel", 1, 1, sched_get_priority_min); + LIB_FUNCTION("O6gKl8uvGyE", "libkernel", 1, "libkernel", 1, 1, sched_getparam); + LIB_FUNCTION("SD7oNCIQWvE", "libkernel", 1, "libkernel", 1, 1, sched_getscheduler); + LIB_FUNCTION("PrsRaaSO-X0", "libkernel", 1, "libkernel", 1, 1, sched_rr_get_interval); + LIB_FUNCTION("yawdym+zDvw", "libkernel", 1, "libkernel", 1, 1, sched_setparam); + LIB_FUNCTION("puT82CSQzDE", "libkernel", 1, "libkernel", 1, 1, sched_setscheduler); + LIB_FUNCTION("6XG4B33N09g", "libkernel", 1, "libkernel", 1, 1, sched_yield); + LIB_FUNCTION("T8fER+tIGgk", "libkernel", 1, "libkernel", 1, 1, select); + LIB_FUNCTION("5gXnxR+pdUo", "libkernel", 1, "libkernel", 1, 1, sem_close); + LIB_FUNCTION("cDW233RAwWo", "libkernel", 1, "libkernel", 1, 1, sem_destroy); + LIB_FUNCTION("Bq+LRV-N6Hk", "libkernel", 1, "libkernel", 1, 1, sem_getvalue); + LIB_FUNCTION("pDuPEf3m4fI", "libkernel", 1, "libkernel", 1, 1, sem_init); + LIB_FUNCTION("+P6FRnQJc1E", "libkernel", 1, "libkernel", 1, 1, sem_open); + LIB_FUNCTION("IKP8typ0QUk", "libkernel", 1, "libkernel", 1, 1, sem_post); + LIB_FUNCTION("4SbrhCozqQU", "libkernel", 1, "libkernel", 1, 1, sem_reltimedwait_np); + LIB_FUNCTION("-wUggz2S5yk", "libkernel", 1, "libkernel", 1, 1, sem_setname); + LIB_FUNCTION("w5IHyvahg-o", "libkernel", 1, "libkernel", 1, 1, sem_timedwait); + LIB_FUNCTION("WBWzsRifCEA", "libkernel", 1, "libkernel", 1, 1, sem_trywait); + LIB_FUNCTION("OiunYlyJUvc", "libkernel", 1, "libkernel", 1, 1, sem_unlink); + LIB_FUNCTION("YCV5dGGBcCo", "libkernel", 1, "libkernel", 1, 1, sem_wait); + LIB_FUNCTION("fZOeZIOEmLw", "libkernel", 1, "libkernel", 1, 1, send); + LIB_FUNCTION("YA0r4LCkfeY", "libkernel", 1, "libkernel", 1, 1, sendfile); + LIB_FUNCTION("aNeavPDNKzA", "libkernel", 1, "libkernel", 1, 1, sendmsg); + LIB_FUNCTION("oBr313PppNE", "libkernel", 1, "libkernel", 1, 1, sendto); + LIB_FUNCTION("mm0znr-xjqI", "libkernel", 1, "libkernel", 1, 1, set_phys_fmem_limit); + LIB_FUNCTION("2VRU7xiqLO8", "libkernel", 1, "libkernel", 1, 1, setcontext); + LIB_FUNCTION("4oKwKmeOKjM", "libkernel", 1, "libkernel", 1, 1, setegid); + LIB_FUNCTION("HTxb6gmexa0", "libkernel", 1, "libkernel", 1, 1, seteuid); + LIB_FUNCTION("M8VZ3iIlmyg", "libkernel", 1, "libkernel", 1, 1, setgroups); + LIB_FUNCTION("hPWDGx8ioXQ", "libkernel", 1, "libkernel", 1, 1, setitimer); + LIB_FUNCTION("TUC9xC1YQjs", "libkernel", 1, "libkernel", 1, 1, setpriority); + LIB_FUNCTION("ROILLZdYZPc", "libkernel", 1, "libkernel", 1, 1, setregid); + LIB_FUNCTION("6w8tPp+Yk6E", "libkernel", 1, "libkernel", 1, 1, setreuid); + LIB_FUNCTION("4X0QwvuCfjc", "libkernel", 1, "libkernel", 1, 1, setrlimit); + LIB_FUNCTION("fFxGkxF2bVo", "libkernel", 1, "libkernel", 1, 1, setsockopt); + LIB_FUNCTION("VdXIDAbJ3tQ", "libkernel", 1, "libkernel", 1, 1, settimeofday); + LIB_FUNCTION("JVmUZwK-HJU", "libkernel", 1, "libkernel", 1, 1, setuid); + LIB_FUNCTION("QuJYZ2KVGGQ", "libkernel", 1, "libkernel", 1, 1, shm_open); + LIB_FUNCTION("tPWsbOUGO8k", "libkernel", 1, "libkernel", 1, 1, shm_unlink); + LIB_FUNCTION("TUuiYS2kE8s", "libkernel", 1, "libkernel", 1, 1, shutdown); + LIB_FUNCTION("KiJEPEWRyUY", "libkernel", 1, "libkernel", 1, 1, sigaction); + LIB_FUNCTION("JUimFtKe0Kc", "libkernel", 1, "libkernel", 1, 1, sigaddset); + LIB_FUNCTION("sHziAegVp74", "libkernel", 1, "libkernel", 1, 1, sigaltstack); + LIB_FUNCTION("Nd-u09VFSCA", "libkernel", 1, "libkernel", 1, 1, sigdelset); + LIB_FUNCTION("+F7C-hdk7+E", "libkernel", 1, "libkernel", 1, 1, sigemptyset); + LIB_FUNCTION("VkTAsrZDcJ0", "libkernel", 1, "libkernel", 1, 1, sigfillset); + LIB_FUNCTION("JnNl8Xr-z4Y", "libkernel", 1, "libkernel", 1, 1, sigismember); + LIB_FUNCTION("pebqbE5ws8s", "libkernel", 1, "libkernel", 1, 1, siglongjmp); + LIB_FUNCTION("VADc3MNQ3cM", "libkernel", 1, "libkernel", 1, 1, signal); + LIB_FUNCTION("hpoDTzy9Yy0", "libkernel", 1, "libkernel", 1, 1, sigpending); + LIB_FUNCTION("aPcyptbOiZs", "libkernel", 1, "libkernel", 1, 1, sigprocmask); + LIB_FUNCTION("TJG6tf+yJlY", "libkernel", 1, "libkernel", 1, 1, sigqueue); + LIB_FUNCTION("mo0bFmWppIw", "libkernel", 1, "libkernel", 1, 1, sigreturn); + LIB_FUNCTION("aRo9AhFUXcM", "libkernel", 1, "libkernel", 1, 1, sigsetjmp); + LIB_FUNCTION("KZ-4qlqlpmo", "libkernel", 1, "libkernel", 1, 1, sigsuspend); + LIB_FUNCTION("D2-dIoJ0ZtE", "libkernel", 1, "libkernel", 1, 1, sigtimedwait); + LIB_FUNCTION("mrbHXqK8wkg", "libkernel", 1, "libkernel", 1, 1, sigwait); + LIB_FUNCTION("Uq5BGthgbl4", "libkernel", 1, "libkernel", 1, 1, sigwaitinfo); + LIB_FUNCTION("0wu33hunNdE", "libkernel", 1, "libkernel", 1, 1, sleep); + LIB_FUNCTION("TU-d9PfIHPM", "libkernel", 1, "libkernel", 1, 1, socket); + LIB_FUNCTION("MZb0GKT3mo8", "libkernel", 1, "libkernel", 1, 1, socketpair); + LIB_FUNCTION("E6ao34wPw+U", "libkernel", 1, "libkernel", 1, 1, stat); + LIB_FUNCTION("EXH1U-UBywI", "libkernel", 1, "libkernel", 1, 1, swapcontext); + LIB_FUNCTION("Y2OqwJQ3lr8", "libkernel", 1, "libkernel", 1, 1, sync); + LIB_FUNCTION("b7uXQmnfB2s", "libkernel", 1, "libkernel", 1, 1, sysarch); + LIB_FUNCTION("mkawd0NA9ts", "libkernel", 1, "libkernel", 1, 1, sysconf); + LIB_FUNCTION("DFmMT80xcNI", "libkernel", 1, "libkernel", 1, 1, sysctl); + LIB_FUNCTION("MhC53TKmjVA", "libkernel", 1, "libkernel", 1, 1, sysctlbyname); + LIB_FUNCTION("UkEV4hvMo1E", "libkernel", 1, "libkernel", 1, 1, sysctlnametomib); + LIB_FUNCTION("EIZbVQs381s", "libkernel", 1, "libkernel", 1, 1, sysKernelGetIntdevModeForRcmgr); + LIB_FUNCTION("7dulKcLcwHI", "libkernel", 1, "libkernel", 1, 1, + sysKernelGetLowerLimitSysexVersion); + LIB_FUNCTION("MMSo+k+Wp0Y", "libkernel", 1, "libkernel", 1, 1, + sysKernelGetLowerLimitUpdVersion); + LIB_FUNCTION("6jj29MbyzuI", "libkernel", 1, "libkernel", 1, 1, sysKernelGetManufacturingMode); + LIB_FUNCTION("1U-s6o8XOcE", "libkernel", 1, "libkernel", 1, 1, sysKernelGetUpdVersion); + LIB_FUNCTION("Jc6E7N+dHz0", "libkernel", 1, "libkernel", 1, 1, system); + LIB_FUNCTION("brGGJWsZauw", "libkernel", 1, "libkernel", 1, 1, tcdrain); + LIB_FUNCTION("OG8xRaGIpqk", "libkernel", 1, "libkernel", 1, 1, tcflow); + LIB_FUNCTION("FxHW5NuEXsY", "libkernel", 1, "libkernel", 1, 1, tcflush); + LIB_FUNCTION("5kBfZ40bAuk", "libkernel", 1, "libkernel", 1, 1, tcgetattr); + LIB_FUNCTION("5OEl1mRhUm0", "libkernel", 1, "libkernel", 1, 1, tcgetpgrp); + LIB_FUNCTION("7ga3x+36xrU", "libkernel", 1, "libkernel", 1, 1, tcgetsid); + LIB_FUNCTION("vXE-dIUIZlE", "libkernel", 1, "libkernel", 1, 1, tcsendbreak); + LIB_FUNCTION("La7xW-jcZwQ", "libkernel", 1, "libkernel", 1, 1, tcsetattr); + LIB_FUNCTION("YMuesZTyTl4", "libkernel", 1, "libkernel", 1, 1, tcsetpgrp); + LIB_FUNCTION("S76vfDNu6eI", "libkernel", 1, "libkernel", 1, 1, tcsetsid); + LIB_FUNCTION("ayrtszI7GBg", "libkernel", 1, "libkernel", 1, 1, truncate); + LIB_FUNCTION("VAzswvTOCzI", "libkernel", 1, "libkernel", 1, 1, unlink); + LIB_FUNCTION("QcteRwbsnV0", "libkernel", 1, "libkernel", 1, 1, usleep); + LIB_FUNCTION("GDuV00CHrUg", "libkernel", 1, "libkernel", 1, 1, utimes); + LIB_FUNCTION("PlmVIwQdarI", "libkernel", 1, "libkernel", 1, 1, uuidgen); + LIB_FUNCTION("ldVb3lc75PE", "libkernel", 1, "libkernel", 1, 1, wait); + LIB_FUNCTION("NKF4F8SQyx4", "libkernel", 1, "libkernel", 1, 1, wait3); + LIB_FUNCTION("dTnYqqLIQ6c", "libkernel", 1, "libkernel", 1, 1, waitpid); + LIB_FUNCTION("FN4gaPmuFV8", "libkernel", 1, "libkernel", 1, 1, write); + LIB_FUNCTION("Z2aKdxzS4KE", "libkernel", 1, "libkernel", 1, 1, writev); + LIB_FUNCTION("N94a0T4F4+U", "libkernel", 1, "libkernel", 1, 1, Func_37DE1AD13E05E3E5); + LIB_FUNCTION("cafDxa64sO4", "libkernel", 1, "libkernel", 1, 1, Func_71A7C3C5AEB8B0EE); + LIB_FUNCTION("gpgi-GwE2Is", "libkernel", 1, "libkernel", 1, 1, Func_829822FC6C04D88B); + LIB_FUNCTION("hmqw8GlN+tI", "libkernel", 1, "libkernel", 1, 1, Func_866AB0F0694DFAD2); + LIB_FUNCTION("jMuNoBRCPUg", "libkernel", 1, "libkernel", 1, 1, Func_8CCB8DA014423D48); + LIB_FUNCTION("qtHOLtFWq7Y", "libkernel", 1, "libkernel", 1, 1, Func_AAD1CE2ED156ABB6); + LIB_FUNCTION("uV+YilcHqAs", "libkernel", 1, "libkernel", 1, 1, Func_B95F988A5707A80B); + LIB_FUNCTION("vfYaxkxnJXQ", "libkernel", 1, "libkernel", 1, 1, Func_BDF61AC64C672574); + LIB_FUNCTION("v+qTlNjF6kE", "libkernel", 1, "libkernel", 1, 1, Func_BFEA9394D8C5EA41); + LIB_FUNCTION("x0DQK0TXDk0", "libkernel", 1, "libkernel", 1, 1, Func_C740D02B44D70E4D); + LIB_FUNCTION("1v23w7Rnkic", "libkernel", 1, "libkernel", 1, 1, Func_D6FDB7C3B4679227); + LIB_FUNCTION("2wKjID0iGVM", "libkernel", 1, "libkernel", 1, 1, Func_DB02A3203D221953); + LIB_FUNCTION("2xg4JXvaJ6k", "libkernel", 1, "libkernel", 1, 1, Func_DB1838257BDA27A9); + LIB_FUNCTION("-PNB3tfnD8c", "libkernel", 1, "libkernel", 1, 1, Func_FCF341DED7E70FC7); + LIB_FUNCTION("-uPq82VbRMI", "libkernel", 1, "libkernel", 1, 1, Func_FEE3EAF3655B44C2); + LIB_FUNCTION("usHTMoFoBTM", "libkernel_dmem_aliasing", 1, "libkernel", 1, 1, + sceKernelEnableDmemAliasing); + LIB_FUNCTION("MR221Mwo0Pc", "libkernel_ps2emu", 1, "libkernel", 1, 1, + sceKernelJitCreateAliasOfSharedMemory); + LIB_FUNCTION("avvJ3J0H0EY", "libkernel_ps2emu", 1, "libkernel", 1, 1, + sceKernelJitCreateSharedMemory); + LIB_FUNCTION("9yxlvURJU6U", "libkernel_ps2emu", 1, "libkernel", 1, 1, + sceKernelJitGetSharedMemoryInfo); + LIB_FUNCTION("YKT49TOLQWs", "libkernel_ps2emu", 1, "libkernel", 1, 1, + sceKernelJitMapSharedMemory); + LIB_FUNCTION("MZb0GKT3mo8", "libkernel_ps2emu", 1, "libkernel", 1, 1, socketpair); + LIB_FUNCTION("aNz11fnnzi4", "libkernel_avlfmem", 1, "libkernel", 1, 1, + sceKernelAvailableFlexibleMemorySize); + LIB_FUNCTION("NhL5qID2iho", "libkernel_cpumode", 1, "libkernel", 1, 1, + sceKernelAddCpumodeEvent); + LIB_FUNCTION("OwjivtyfODU", "libkernel_cpumode", 1, "libkernel", 1, 1, + sceKernelDeleteCpumodeEvent); + LIB_FUNCTION("VOx8NGmHXTs", "libkernel_cpumode", 1, "libkernel", 1, 1, sceKernelGetCpumode); + LIB_FUNCTION("VjBtg5Btl94", "libkernel_cpumode", 1, "libkernel", 1, 1, sceKernelSetFsstParam); + LIB_FUNCTION("BtJ3gH33xss", "libkernel_cpumode", 1, "libkernel", 1, 1, sceKernelYieldCpumode); + LIB_FUNCTION("YJ7JscWubcU", "libkernel_exception", 1, "libkernel", 1, 1, + sceKernelAddGpuExceptionEvent); + LIB_FUNCTION("xRwvvcfZfHM", "libkernel_exception", 1, "libkernel", 1, 1, + sceKernelBacktraceSelf); + LIB_FUNCTION("8skggWXlSqM", "libkernel_exception", 1, "libkernel", 1, 1, + sceKernelDeleteGpuExceptionEvent); + LIB_FUNCTION("WkwEd3N7w0Y", "libkernel_exception", 1, "libkernel", 1, 1, + sceKernelInstallExceptionHandler); + LIB_FUNCTION("Qhv5ARAoOEc", "libkernel_exception", 1, "libkernel", 1, 1, + sceKernelRemoveExceptionHandler); + LIB_FUNCTION("mpxAdqW7dKY", "libkernel_cpumode_platform", 1, "libkernel", 1, 1, + sceKernelIsProspero); + LIB_FUNCTION("usHTMoFoBTM", "libkernel_dmem_aliasing2", 1, "libkernel", 1, 1, + sceKernelEnableDmemAliasing); + LIB_FUNCTION("usHTMoFoBTM", "libkernel_dmem_aliasing2_for_dev", 1, "libkernel", 1, 1, + sceKernelEnableDmemAliasing); + LIB_FUNCTION("DLORcroUqbc", "libSceOpenPsId", 1, "libkernel", 1, 1, sceKernelGetOpenPsId); + LIB_FUNCTION("wdUufa9g-D8", "libkernel_jvm", 1, "libkernel", 1, 1, dup2); + LIB_FUNCTION("Wh7HbV7JFqc", "libkernel_jvm", 1, "libkernel", 1, 1, getrlimit); + LIB_FUNCTION("PfccT7qURYE", "libkernel_jvm", 1, "libkernel", 1, 1, ioctl); + LIB_FUNCTION("W0xkN0+ZkCE", "libkernel_jvm", 1, "libkernel", 1, 1, kill); + LIB_FUNCTION("ku7D4q1Y9PI", "libkernel_jvm", 1, "libkernel", 1, 1, poll); + LIB_FUNCTION("yH-uQW3LbX0", "libkernel_jvm", 1, "libkernel", 1, 1, pthread_kill); + LIB_FUNCTION("wJABa1X4+ec", "libkernel_jvm", 1, "libkernel", 1, 1, + sceKernelGetExecutableModuleHandle); + LIB_FUNCTION("MR221Mwo0Pc", "libkernel_jvm", 1, "libkernel", 1, 1, + sceKernelJitCreateAliasOfSharedMemory); + LIB_FUNCTION("avvJ3J0H0EY", "libkernel_jvm", 1, "libkernel", 1, 1, + sceKernelJitCreateSharedMemory); + LIB_FUNCTION("9yxlvURJU6U", "libkernel_jvm", 1, "libkernel", 1, 1, + sceKernelJitGetSharedMemoryInfo); + LIB_FUNCTION("YKT49TOLQWs", "libkernel_jvm", 1, "libkernel", 1, 1, sceKernelJitMapSharedMemory); + LIB_FUNCTION("4X0QwvuCfjc", "libkernel_jvm", 1, "libkernel", 1, 1, setrlimit); + LIB_FUNCTION("KiJEPEWRyUY", "libkernel_jvm", 1, "libkernel", 1, 1, sigaction); + LIB_FUNCTION("JUimFtKe0Kc", "libkernel_jvm", 1, "libkernel", 1, 1, sigaddset); + LIB_FUNCTION("Nd-u09VFSCA", "libkernel_jvm", 1, "libkernel", 1, 1, sigdelset); + LIB_FUNCTION("+F7C-hdk7+E", "libkernel_jvm", 1, "libkernel", 1, 1, sigemptyset); + LIB_FUNCTION("VkTAsrZDcJ0", "libkernel_jvm", 1, "libkernel", 1, 1, sigfillset); + LIB_FUNCTION("JnNl8Xr-z4Y", "libkernel_jvm", 1, "libkernel", 1, 1, sigismember); + LIB_FUNCTION("aPcyptbOiZs", "libkernel_jvm", 1, "libkernel", 1, 1, sigprocmask); + LIB_FUNCTION("KZ-4qlqlpmo", "libkernel_jvm", 1, "libkernel", 1, 1, sigsuspend); + LIB_FUNCTION("MZb0GKT3mo8", "libkernel_jvm", 1, "libkernel", 1, 1, socketpair); + LIB_FUNCTION("mkawd0NA9ts", "libkernel_jvm", 1, "libkernel", 1, 1, sysconf); + LIB_FUNCTION("DFmMT80xcNI", "libkernel_jvm", 1, "libkernel", 1, 1, sysctl); + LIB_FUNCTION("ClMdHuu+R1A", "libkernel_module_extension", 1, "libkernel", 1, 1, + Func_0A531D1EEBBE4750); + LIB_FUNCTION("WkwEd3N7w0Y", "libkernel_unity", 1, "libkernel", 1, 1, + sceKernelInstallExceptionHandler); + LIB_FUNCTION("il03nluKfMk", "libkernel_unity", 1, "libkernel", 1, 1, sceKernelRaiseException); + LIB_FUNCTION("Qhv5ARAoOEc", "libkernel_unity", 1, "libkernel", 1, 1, + sceKernelRemoveExceptionHandler); + LIB_FUNCTION("QgsKEUfkqMA", "libkernel_module_info", 1, "libkernel", 1, 1, + sceKernelGetModuleInfo2); + LIB_FUNCTION("ZzzC3ZGVAkc", "libkernel_module_info", 1, "libkernel", 1, 1, + sceKernelGetModuleList2); + LIB_FUNCTION("21+rb7xOlJk", "libkernel_module_load_check", 1, "libkernel", 1, 1, + sceKernelIsModuleLoaded); + LIB_FUNCTION("2SKEx6bSq-4", "libkernel_pre250mmap", 1, "libkernel", 1, 1, sceKernelBatchMap); + LIB_FUNCTION("L-Q3LEjIbgA", "libkernel_pre250mmap", 1, "libkernel", 1, 1, + sceKernelMapDirectMemory); + LIB_FUNCTION("NcaWUxfMNIQ", "libkernel_pre250mmap", 1, "libkernel", 1, 1, + sceKernelMapNamedDirectMemory); + LIB_FUNCTION("8vE6Z6VEYyk", "libkernel_psmkit", 1, "libkernel", 1, 1, access); + LIB_FUNCTION("6mMQ1MSPW-Q", "libkernel_psmkit", 1, "libkernel", 1, 1, chdir); + LIB_FUNCTION("iiQjzvfWDq0", "libkernel_psmkit", 1, "libkernel", 1, 1, dup); + LIB_FUNCTION("wdUufa9g-D8", "libkernel_psmkit", 1, "libkernel", 1, 1, dup2); + LIB_FUNCTION("PfccT7qURYE", "libkernel_psmkit", 1, "libkernel", 1, 1, ioctl); + LIB_FUNCTION("DRGXpDDh8Ng", "libkernel_psmkit", 1, "libkernel", 1, 1, lstat); + LIB_FUNCTION("-Jp7F+pXxNg", "libkernel_psmkit", 1, "libkernel", 1, 1, pipe); + LIB_FUNCTION("ku7D4q1Y9PI", "libkernel_psmkit", 1, "libkernel", 1, 1, poll); + LIB_FUNCTION("EZ8h70dtFLg", "libkernel_psmkit", 1, "libkernel", 1, 1, pthread_cond_setname_np); + LIB_FUNCTION("YkGOXpJEtO8", "libkernel_psmkit", 1, "libkernel", 1, 1, + pthread_get_user_context_np); + LIB_FUNCTION("yH-uQW3LbX0", "libkernel_psmkit", 1, "libkernel", 1, 1, pthread_kill); + LIB_FUNCTION("nbQ0bXMRlhk", "libkernel_psmkit", 1, "libkernel", 1, 1, + pthread_mutex_reltimedlock_np); + LIB_FUNCTION("nTxZBp8YNGc", "libkernel_psmkit", 1, "libkernel", 1, 1, pthread_mutex_setname_np); + LIB_FUNCTION("QRdE7dBfNks", "libkernel_psmkit", 1, "libkernel", 1, 1, + pthread_resume_user_context_np); + LIB_FUNCTION("cfjAjVTFG6A", "libkernel_psmkit", 1, "libkernel", 1, 1, + pthread_suspend_user_context_np); + LIB_FUNCTION("OMDRKKAZ8I4", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelDebugRaiseException); + LIB_FUNCTION("DKWTYfo-jMY", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelDebugRaiseExceptionWithContext); + LIB_FUNCTION("JGfTMBOdUJo", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelGetFsSandboxRandomWord); + LIB_FUNCTION("f7KBOafysXo", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelGetModuleInfoFromAddr); + LIB_FUNCTION("MR221Mwo0Pc", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelJitCreateAliasOfSharedMemory); + LIB_FUNCTION("avvJ3J0H0EY", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelJitCreateSharedMemory); + LIB_FUNCTION("YKT49TOLQWs", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelJitMapSharedMemory); + LIB_FUNCTION("MwhHNKdBXq8", "libkernel_psmkit", 1, "libkernel", 1, 1, sceKernelOpenSema); + LIB_FUNCTION("-W4xI5aVI8w", "libkernel_psmkit", 1, "libkernel", 1, 1, + sceKernelSetProcessProperty); + LIB_FUNCTION("-wUggz2S5yk", "libkernel_psmkit", 1, "libkernel", 1, 1, sem_setname); + LIB_FUNCTION("KiJEPEWRyUY", "libkernel_psmkit", 1, "libkernel", 1, 1, sigaction); + LIB_FUNCTION("JUimFtKe0Kc", "libkernel_psmkit", 1, "libkernel", 1, 1, sigaddset); + LIB_FUNCTION("sHziAegVp74", "libkernel_psmkit", 1, "libkernel", 1, 1, sigaltstack); + LIB_FUNCTION("Nd-u09VFSCA", "libkernel_psmkit", 1, "libkernel", 1, 1, sigdelset); + LIB_FUNCTION("+F7C-hdk7+E", "libkernel_psmkit", 1, "libkernel", 1, 1, sigemptyset); + LIB_FUNCTION("VkTAsrZDcJ0", "libkernel_psmkit", 1, "libkernel", 1, 1, sigfillset); + LIB_FUNCTION("JnNl8Xr-z4Y", "libkernel_psmkit", 1, "libkernel", 1, 1, sigismember); + LIB_FUNCTION("VADc3MNQ3cM", "libkernel_psmkit", 1, "libkernel", 1, 1, signal); + LIB_FUNCTION("aPcyptbOiZs", "libkernel_psmkit", 1, "libkernel", 1, 1, sigprocmask); + LIB_FUNCTION("KZ-4qlqlpmo", "libkernel_psmkit", 1, "libkernel", 1, 1, sigsuspend); + LIB_FUNCTION("MZb0GKT3mo8", "libkernel_psmkit", 1, "libkernel", 1, 1, socketpair); + LIB_FUNCTION("mkawd0NA9ts", "libkernel_psmkit", 1, "libkernel", 1, 1, sysconf); + LIB_FUNCTION("PfccT7qURYE", "libkernel_qadisc", 1, "libkernel", 1, 1, ioctl); + LIB_FUNCTION("CA5jcDb2vYI", "libkernel_qadisc", 1, "libkernel", 1, 1, + sceKernelGetSocPowerConsumption); + LIB_FUNCTION("U0NKl-rjhYA", "libkernel_qadisc", 1, "libkernel", 1, 1, sceKernelIccGetCountTime); + LIB_FUNCTION("8TqMzIggthc", "libkernel_qadisc", 1, "libkernel", 1, 1, sceKernelIccGetErrLog); + LIB_FUNCTION("C+i9gJY4A1I", "libkernel_qadisc", 1, "libkernel", 1, 1, sceKernelIccGetHwInfo); + LIB_FUNCTION("L21PBFwqIiM", "libkernel_qadisc", 1, "libkernel", 1, 1, + sceKernelIccGetSysEventLog); + LIB_FUNCTION("gpgi-GwE2Is", "libkernel_qadisc", 1, "libkernel", 1, 1, Func_829822FC6C04D88B); + LIB_FUNCTION("uV+YilcHqAs", "libkernel_qadisc", 1, "libkernel", 1, 1, Func_B95F988A5707A80B); + LIB_FUNCTION("nSSPVGJLMjE", "libkernel_sysc_se", 1, "libkernel", 1, 1, __freeze); + LIB_FUNCTION("eaiyhIBmf34", "libkernel_sysc_se", 1, "libkernel", 1, 1, sysc_e00); + LIB_FUNCTION("XPlTYt2TOg0", "libkernel_sysc_se", 1, "libkernel", 1, 1, sysc_s00); + LIB_FUNCTION("+YX0z-GUSNw", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpAttachMemoryRegion); + LIB_FUNCTION("MEJ7tc7ThwM", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpAttachMemoryRegionAsUserFile); + LIB_FUNCTION("5nc2gdLNsok", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpAttachUserFile); + LIB_FUNCTION("DoKHmUw1yiQ", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpAttachUserMemoryFile); + LIB_FUNCTION("gzLt9Qrauk0", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpConfigDumpMode); + LIB_FUNCTION("dei8oUx6DbU", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpDebugTextOut); + LIB_FUNCTION("kK0DUW1Ukgc", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpGetStopInfoCpu); + LIB_FUNCTION("nsyWCTsI3MY", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpGetStopInfoGpu); + LIB_FUNCTION("ShChva57wIM", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpGetThreadContextInfo); + LIB_FUNCTION("qCDIxJL+IN8", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpInternalGetThreadContextInfo); + LIB_FUNCTION("8zLSfEfW5AU", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpRegisterCoredumpHandler); + LIB_FUNCTION("Uxqkdta7wEg", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpSetUserDataType); + LIB_FUNCTION("fFkhOgztiCA", "libSceCoredump", 1, "libkernel", 1, 1, + sceCoredumpUnregisterCoredumpHandler); + LIB_FUNCTION("Dbbkj6YHWdo", "libSceCoredump", 1, "libkernel", 1, 1, sceCoredumpWriteUserData); + LIB_FUNCTION("mIkJUpP5vKo", "libSceCoredump", 1, "libkernel", 1, 1, Func_9889095293F9BCAA); + LIB_FUNCTION("1Pw5n31Ayxc", "libSceCoredump_debug", 1, "libkernel", 1, 1, + sceCoredumpDebugForceCoredumpOnAppClose); + LIB_FUNCTION("G420P25pN5Y", "libSceCoredump_debug", 1, "libkernel", 1, 1, + sceCoredumpDebugTriggerCoredump); + LIB_FUNCTION("3e+4Iv7IJ8U", "libScePosix", 1, "libkernel", 1, 1, accept); + LIB_FUNCTION("KuOmgKoqCdY", "libScePosix", 1, "libkernel", 1, 1, bind); + LIB_FUNCTION("ixrw0h2tWuI", "libScePosix", 1, "libkernel", 1, 1, chflags); + LIB_FUNCTION("z0dtnPxYgtg", "libScePosix", 1, "libkernel", 1, 1, chmod); + LIB_FUNCTION("smIj7eqzZE8", "libScePosix", 1, "libkernel", 1, 1, clock_getres); + LIB_FUNCTION("lLMT9vJAck0", "libScePosix", 1, "libkernel", 1, 1, clock_gettime); + LIB_FUNCTION("bY-PO6JhzhQ", "libScePosix", 1, "libkernel", 1, 1, close); + LIB_FUNCTION("XVL8So3QJUk", "libScePosix", 1, "libkernel", 1, 1, connect); + LIB_FUNCTION("5AMS0IntU8I", "libScePosix", 1, "libkernel", 1, 1, creat); + LIB_FUNCTION("UJrQCyYpyic", "libScePosix", 1, "libkernel", 1, 1, fchflags); + LIB_FUNCTION("n01yNbQO5W4", "libScePosix", 1, "libkernel", 1, 1, fchmod); + LIB_FUNCTION("8nY19bKoiZk", "libScePosix", 1, "libkernel", 1, 1, fcntl); + LIB_FUNCTION("9eMlfusH4sU", "libScePosix", 1, "libkernel", 1, 1, flock); + LIB_FUNCTION("mqQMh1zPPT8", "libScePosix", 1, "libkernel", 1, 1, fstat); + LIB_FUNCTION("juWbTNM+8hw", "libScePosix", 1, "libkernel", 1, 1, fsync); + LIB_FUNCTION("ih4CD9-gghM", "libScePosix", 1, "libkernel", 1, 1, ftruncate); + LIB_FUNCTION("+0EDo7YzcoU", "libScePosix", 1, "libkernel", 1, 1, futimes); + LIB_FUNCTION("dar03AOn+nM", "libScePosix", 1, "libkernel", 1, 1, getcontext); + LIB_FUNCTION("2G6i6hMIUUY", "libScePosix", 1, "libkernel", 1, 1, getdents); + LIB_FUNCTION("f09KvIPy-QY", "libScePosix", 1, "libkernel", 1, 1, getdirentries); + LIB_FUNCTION("sZuwaDPATKs", "libScePosix", 1, "libkernel", 1, 1, getdtablesize); + LIB_FUNCTION("k+AXqu2-eBc", "libScePosix", 1, "libkernel", 1, 1, getpagesize); + LIB_FUNCTION("TXFFFiNldU8", "libScePosix", 1, "libkernel", 1, 1, getpeername); + LIB_FUNCTION("HoLVWNanBBc", "libScePosix", 1, "libkernel", 1, 1, getpid); + LIB_FUNCTION("RenI1lL1WFk", "libScePosix", 1, "libkernel", 1, 1, getsockname); + LIB_FUNCTION("6O8EwYOgH9Y", "libScePosix", 1, "libkernel", 1, 1, getsockopt); + LIB_FUNCTION("n88vx3C5nW8", "libScePosix", 1, "libkernel", 1, 1, gettimeofday); + LIB_FUNCTION("K1S8oc61xiM", "libScePosix", 1, "libkernel", 1, 1, htonl); + LIB_FUNCTION("jogUIsOV3-U", "libScePosix", 1, "libkernel", 1, 1, htons); + LIB_FUNCTION("5jRCs2axtr4", "libScePosix", 1, "libkernel", 1, 1, inet_ntop); + LIB_FUNCTION("4n51s0zEf0c", "libScePosix", 1, "libkernel", 1, 1, inet_pton); + LIB_FUNCTION("RW-GEfpnsqg", "libScePosix", 1, "libkernel", 1, 1, kevent); + LIB_FUNCTION("nh2IFMgKTv8", "libScePosix", 1, "libkernel", 1, 1, kqueue); + LIB_FUNCTION("pxnCmagrtao", "libScePosix", 1, "libkernel", 1, 1, listen); + LIB_FUNCTION("Oy6IpwgtYOk", "libScePosix", 1, "libkernel", 1, 1, lseek); + LIB_FUNCTION("Jahsnh4KKkg", "libScePosix", 1, "libkernel", 1, 1, madvise); + LIB_FUNCTION("JGMio+21L4c", "libScePosix", 1, "libkernel", 1, 1, mkdir); + LIB_FUNCTION("mTBZfEal2Bw", "libScePosix", 1, "libkernel", 1, 1, mlock); + LIB_FUNCTION("x7g7Ebeo8-U", "libScePosix", 1, "libkernel", 1, 1, mlockall); + LIB_FUNCTION("BPE9s9vQQXo", "libScePosix", 1, "libkernel", 1, 1, mmap); + LIB_FUNCTION("YQOfxL4QfeU", "libScePosix", 1, "libkernel", 1, 1, mprotect); + LIB_FUNCTION("tZY4+SZNFhA", "libScePosix", 1, "libkernel", 1, 1, msync); + LIB_FUNCTION("OG4RsDwLguo", "libScePosix", 1, "libkernel", 1, 1, munlock); + LIB_FUNCTION("NpLBpgVV7PU", "libScePosix", 1, "libkernel", 1, 1, munlockall); + LIB_FUNCTION("UqDGjXA5yUM", "libScePosix", 1, "libkernel", 1, 1, munmap); + LIB_FUNCTION("yS8U2TGCe1A", "libScePosix", 1, "libkernel", 1, 1, nanosleep); + LIB_FUNCTION("jct5WjixLgk", "libScePosix", 1, "libkernel", 1, 1, ntohl); + LIB_FUNCTION("oLFi+HuZ7hY", "libScePosix", 1, "libkernel", 1, 1, ntohs); + LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, open); + LIB_FUNCTION("ezv-RSBNKqI", "libScePosix", 1, "libkernel", 1, 1, pread); + LIB_FUNCTION("ZaRzaapAZwM", "libScePosix", 1, "libkernel", 1, 1, preadv); + LIB_FUNCTION("zHchY8ft5pk", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_destroy); + LIB_FUNCTION("Ucsu-OK+els", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_get_np); + LIB_FUNCTION("VUT1ZSrHT0I", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getdetachstate); + LIB_FUNCTION("JNkVVsVDmOk", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getguardsize); + LIB_FUNCTION("oLjPqUKhzes", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getinheritsched); + LIB_FUNCTION("qlk9pSLsUmM", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getschedparam); + LIB_FUNCTION("RtLRV-pBTTY", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getschedpolicy); + LIB_FUNCTION("e2G+cdEkOmU", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getscope); + LIB_FUNCTION("vQm4fDEsWi8", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getstack); + LIB_FUNCTION("DxmIMUQ-wXY", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getstackaddr); + LIB_FUNCTION("0qOtCR-ZHck", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_getstacksize); + LIB_FUNCTION("wtkt-teR1so", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_init); + LIB_FUNCTION("E+tyo3lp5Lw", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setdetachstate); + LIB_FUNCTION("JKyG3SWyA10", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setguardsize); + LIB_FUNCTION("7ZlAakEf0Qg", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setinheritsched); + LIB_FUNCTION("euKRgm0Vn2M", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setschedparam); + LIB_FUNCTION("JarMIy8kKEY", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setschedpolicy); + LIB_FUNCTION("xesmlSI-KCI", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setscope); + LIB_FUNCTION("-SrbXpGR1f0", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setstack); + LIB_FUNCTION("suCrEbr0xIQ", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setstackaddr); + LIB_FUNCTION("2Q0z6rnBrTE", "libScePosix", 1, "libkernel", 1, 1, pthread_attr_setstacksize); + LIB_FUNCTION("+Pqub9HZCPo", "libScePosix", 1, "libkernel", 1, 1, pthread_barrier_destroy); + LIB_FUNCTION("ZsXLFtd2jqQ", "libScePosix", 1, "libkernel", 1, 1, pthread_barrier_init); + LIB_FUNCTION("CawZgCYqXWk", "libScePosix", 1, "libkernel", 1, 1, pthread_barrier_wait); + LIB_FUNCTION("AsCQCYTbe80", "libScePosix", 1, "libkernel", 1, 1, pthread_barrierattr_destroy); + LIB_FUNCTION("a5JZMyjFV68", "libScePosix", 1, "libkernel", 1, 1, + pthread_barrierattr_getpshared); + LIB_FUNCTION("4nqCnLJSvck", "libScePosix", 1, "libkernel", 1, 1, pthread_barrierattr_init); + LIB_FUNCTION("jqrGJJxFhmU", "libScePosix", 1, "libkernel", 1, 1, + pthread_barrierattr_setpshared); + LIB_FUNCTION("0D4-FVvEikw", "libScePosix", 1, "libkernel", 1, 1, pthread_cancel); + LIB_FUNCTION("RVxb0Ssa5t0", "libScePosix", 1, "libkernel", 1, 1, pthread_cleanup_pop); + LIB_FUNCTION("4ZeZWcMsAV0", "libScePosix", 1, "libkernel", 1, 1, pthread_cleanup_push); + LIB_FUNCTION("mkx2fVhNMsg", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_broadcast); + LIB_FUNCTION("RXXqi4CtF8w", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_destroy); + LIB_FUNCTION("0TyVk4MSLt0", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_init); + LIB_FUNCTION("2MOy+rUfuhQ", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_signal); + LIB_FUNCTION("CI6Qy73ae10", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_signalto_np); + LIB_FUNCTION("27bAgiJmOh0", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_timedwait); + LIB_FUNCTION("Op8TBGY5KHg", "libScePosix", 1, "libkernel", 1, 1, pthread_cond_wait); + LIB_FUNCTION("dJcuQVn6-Iw", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_destroy); + LIB_FUNCTION("cTDYxTUNPhM", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_getclock); + LIB_FUNCTION("h0qUqSuOmC8", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_getpshared); + LIB_FUNCTION("mKoTx03HRWA", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_init); + LIB_FUNCTION("EjllaAqAPZo", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_setclock); + LIB_FUNCTION("3BpP850hBT4", "libScePosix", 1, "libkernel", 1, 1, pthread_condattr_setpshared); + LIB_FUNCTION("OxhIB8LB-PQ", "libScePosix", 1, "libkernel", 1, 1, pthread_create); + LIB_FUNCTION("Jmi+9w9u0E4", "libScePosix", 1, "libkernel", 1, 1, pthread_create_name_np); + LIB_FUNCTION("+U1R4WtXvoc", "libScePosix", 1, "libkernel", 1, 1, pthread_detach); + LIB_FUNCTION("7Xl257M4VNI", "libScePosix", 1, "libkernel", 1, 1, pthread_equal); + LIB_FUNCTION("FJrT5LuUBAU", "libScePosix", 1, "libkernel", 1, 1, pthread_exit); + LIB_FUNCTION("s+QHU9RLHS4", "libScePosix", 1, "libkernel", 1, 1, pthread_getconcurrency); + LIB_FUNCTION("nnoxZUHK+SA", "libScePosix", 1, "libkernel", 1, 1, pthread_getcpuclockid); + LIB_FUNCTION("9HzfhdtESio", "libScePosix", 1, "libkernel", 1, 1, pthread_getname_np); + LIB_FUNCTION("aO+WS2xWuo4", "libScePosix", 1, "libkernel", 1, 1, pthread_getprio); + LIB_FUNCTION("FIs3-UQT9sg", "libScePosix", 1, "libkernel", 1, 1, pthread_getschedparam); + LIB_FUNCTION("0-KXaS70xy4", "libScePosix", 1, "libkernel", 1, 1, pthread_getspecific); + LIB_FUNCTION("h9CcP3J0oVM", "libScePosix", 1, "libkernel", 1, 1, pthread_join); + LIB_FUNCTION("mqULNdimTn0", "libScePosix", 1, "libkernel", 1, 1, pthread_key_create); + LIB_FUNCTION("6BpEZuDT7YI", "libScePosix", 1, "libkernel", 1, 1, pthread_key_delete); + LIB_FUNCTION("ltCfaGr2JGE", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_destroy); + LIB_FUNCTION("itv-U5mFPso", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_getprioceiling); + LIB_FUNCTION("ttHNfU+qDBU", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_init); + LIB_FUNCTION("7H0iTOciTLo", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_lock); + LIB_FUNCTION("XS3kGVt4q+4", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_setprioceiling); + LIB_FUNCTION("Io9+nTKXZtA", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_timedlock); + LIB_FUNCTION("K-jXhbt2gn4", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_trylock); + LIB_FUNCTION("2Z+PpY6CaJg", "libScePosix", 1, "libkernel", 1, 1, pthread_mutex_unlock); + LIB_FUNCTION("HF7lK46xzjY", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_destroy); + LIB_FUNCTION("+m8+quqOwhM", "libScePosix", 1, "libkernel", 1, 1, + pthread_mutexattr_getprioceiling); + LIB_FUNCTION("yDaWxUE50s0", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_getprotocol); + LIB_FUNCTION("PmL-TwKUzXI", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_getpshared); + LIB_FUNCTION("GZFlI7RhuQo", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_gettype); + LIB_FUNCTION("dQHWEsJtoE4", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_init); + LIB_FUNCTION("ZLvf6lVAc4M", "libScePosix", 1, "libkernel", 1, 1, + pthread_mutexattr_setprioceiling); + LIB_FUNCTION("5txKfcMUAok", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_setprotocol); + LIB_FUNCTION("EXv3ztGqtDM", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_setpshared); + LIB_FUNCTION("mDmgMOGVUqg", "libScePosix", 1, "libkernel", 1, 1, pthread_mutexattr_settype); + LIB_FUNCTION("Z4QosVuAsA0", "libScePosix", 1, "libkernel", 1, 1, pthread_once); + LIB_FUNCTION("9vyP6Z7bqzc", "libScePosix", 1, "libkernel", 1, 1, pthread_rename_np); + LIB_FUNCTION("1471ajPzxh0", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_destroy); + LIB_FUNCTION("ytQULN-nhL4", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_init); + LIB_FUNCTION("iGjsr1WAtI0", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_rdlock); + LIB_FUNCTION("lb8lnYo-o7k", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_timedrdlock); + LIB_FUNCTION("9zklzAl9CGM", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_timedwrlock); + LIB_FUNCTION("SFxTMOfuCkE", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_tryrdlock); + LIB_FUNCTION("XhWHn6P5R7U", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_trywrlock); + LIB_FUNCTION("EgmLo6EWgso", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_unlock); + LIB_FUNCTION("sIlRvQqsN2Y", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlock_wrlock); + LIB_FUNCTION("qsdmgXjqSgk", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_destroy); + LIB_FUNCTION("VqEMuCv-qHY", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_getpshared); + LIB_FUNCTION("l+bG5fsYkhg", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_gettype_np); + LIB_FUNCTION("xFebsA4YsFI", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_init); + LIB_FUNCTION("OuKg+kRDD7U", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_setpshared); + LIB_FUNCTION("8NuOHiTr1Vw", "libScePosix", 1, "libkernel", 1, 1, pthread_rwlockattr_settype_np); + LIB_FUNCTION("EotR8a3ASf4", "libScePosix", 1, "libkernel", 1, 1, pthread_self); + LIB_FUNCTION("lZzFeSxPl08", "libScePosix", 1, "libkernel", 1, 1, pthread_setcancelstate); + LIB_FUNCTION("2dEhvvjlq30", "libScePosix", 1, "libkernel", 1, 1, pthread_setcanceltype); + LIB_FUNCTION("fBG1gHx1RlI", "libScePosix", 1, "libkernel", 1, 1, pthread_setconcurrency); + LIB_FUNCTION("a2P9wYGeZvc", "libScePosix", 1, "libkernel", 1, 1, pthread_setprio); + LIB_FUNCTION("Xs9hdiD7sAA", "libScePosix", 1, "libkernel", 1, 1, pthread_setschedparam); + LIB_FUNCTION("WrOLvHU0yQM", "libScePosix", 1, "libkernel", 1, 1, pthread_setspecific); + LIB_FUNCTION("JZKw5+Wrnaw", "libScePosix", 1, "libkernel", 1, 1, pthread_sigmask); + LIB_FUNCTION("nYBrkGDqxh8", "libScePosix", 1, "libkernel", 1, 1, pthread_testcancel); + LIB_FUNCTION("B5GmVDKwpn0", "libScePosix", 1, "libkernel", 1, 1, pthread_yield); + LIB_FUNCTION("C2kJ-byS5rM", "libScePosix", 1, "libkernel", 1, 1, pwrite); + LIB_FUNCTION("FCcmRZhWtOk", "libScePosix", 1, "libkernel", 1, 1, pwritev); + LIB_FUNCTION("AqBioC2vF3I", "libScePosix", 1, "libkernel", 1, 1, read); + LIB_FUNCTION("I7ImcLds-uU", "libScePosix", 1, "libkernel", 1, 1, readv); + LIB_FUNCTION("Ez8xjo9UF4E", "libScePosix", 1, "libkernel", 1, 1, recv); + LIB_FUNCTION("lUk6wrGXyMw", "libScePosix", 1, "libkernel", 1, 1, recvfrom); + LIB_FUNCTION("hI7oVeOluPM", "libScePosix", 1, "libkernel", 1, 1, recvmsg); + LIB_FUNCTION("NN01qLRhiqU", "libScePosix", 1, "libkernel", 1, 1, rename); + LIB_FUNCTION("c7ZnT7V1B98", "libScePosix", 1, "libkernel", 1, 1, rmdir); + LIB_FUNCTION("CBNtXOoef-E", "libScePosix", 1, "libkernel", 1, 1, sched_get_priority_max); + LIB_FUNCTION("m0iS6jNsXds", "libScePosix", 1, "libkernel", 1, 1, sched_get_priority_min); + LIB_FUNCTION("O6gKl8uvGyE", "libScePosix", 1, "libkernel", 1, 1, sched_getparam); + LIB_FUNCTION("yawdym+zDvw", "libScePosix", 1, "libkernel", 1, 1, sched_setparam); + LIB_FUNCTION("6XG4B33N09g", "libScePosix", 1, "libkernel", 1, 1, sched_yield); + LIB_FUNCTION("T8fER+tIGgk", "libScePosix", 1, "libkernel", 1, 1, select); + LIB_FUNCTION("cDW233RAwWo", "libScePosix", 1, "libkernel", 1, 1, sem_destroy); + LIB_FUNCTION("Bq+LRV-N6Hk", "libScePosix", 1, "libkernel", 1, 1, sem_getvalue); + LIB_FUNCTION("pDuPEf3m4fI", "libScePosix", 1, "libkernel", 1, 1, sem_init); + LIB_FUNCTION("IKP8typ0QUk", "libScePosix", 1, "libkernel", 1, 1, sem_post); + LIB_FUNCTION("4SbrhCozqQU", "libScePosix", 1, "libkernel", 1, 1, sem_reltimedwait_np); + LIB_FUNCTION("w5IHyvahg-o", "libScePosix", 1, "libkernel", 1, 1, sem_timedwait); + LIB_FUNCTION("WBWzsRifCEA", "libScePosix", 1, "libkernel", 1, 1, sem_trywait); + LIB_FUNCTION("OiunYlyJUvc", "libScePosix", 1, "libkernel", 1, 1, sem_unlink); + LIB_FUNCTION("YCV5dGGBcCo", "libScePosix", 1, "libkernel", 1, 1, sem_wait); + LIB_FUNCTION("fZOeZIOEmLw", "libScePosix", 1, "libkernel", 1, 1, send); + LIB_FUNCTION("aNeavPDNKzA", "libScePosix", 1, "libkernel", 1, 1, sendmsg); + LIB_FUNCTION("oBr313PppNE", "libScePosix", 1, "libkernel", 1, 1, sendto); + LIB_FUNCTION("2VRU7xiqLO8", "libScePosix", 1, "libkernel", 1, 1, setcontext); + LIB_FUNCTION("fFxGkxF2bVo", "libScePosix", 1, "libkernel", 1, 1, setsockopt); + LIB_FUNCTION("TUuiYS2kE8s", "libScePosix", 1, "libkernel", 1, 1, shutdown); + LIB_FUNCTION("0wu33hunNdE", "libScePosix", 1, "libkernel", 1, 1, sleep); + LIB_FUNCTION("TU-d9PfIHPM", "libScePosix", 1, "libkernel", 1, 1, socket); + LIB_FUNCTION("E6ao34wPw+U", "libScePosix", 1, "libkernel", 1, 1, stat); + LIB_FUNCTION("EXH1U-UBywI", "libScePosix", 1, "libkernel", 1, 1, swapcontext); + LIB_FUNCTION("Y2OqwJQ3lr8", "libScePosix", 1, "libkernel", 1, 1, sync); + LIB_FUNCTION("ayrtszI7GBg", "libScePosix", 1, "libkernel", 1, 1, truncate); + LIB_FUNCTION("VAzswvTOCzI", "libScePosix", 1, "libkernel", 1, 1, unlink); + LIB_FUNCTION("QcteRwbsnV0", "libScePosix", 1, "libkernel", 1, 1, usleep); + LIB_FUNCTION("GDuV00CHrUg", "libScePosix", 1, "libkernel", 1, 1, utimes); + LIB_FUNCTION("FN4gaPmuFV8", "libScePosix", 1, "libkernel", 1, 1, write); + LIB_FUNCTION("Z2aKdxzS4KE", "libScePosix", 1, "libkernel", 1, 1, writev);*/ +}; + +} // namespace Libraries::Kernel \ No newline at end of file diff --git a/src/core/libraries/libkernel.h b/src/core/libraries/libkernel.h new file mode 100644 index 00000000..c0cb1fde --- /dev/null +++ b/src/core/libraries/libkernel.h @@ -0,0 +1,1061 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::Kernel { + +int PS4_SYSV_ABI __elf_phdr_match_addr(); +int PS4_SYSV_ABI __error(); +int PS4_SYSV_ABI __freeze(); +int PS4_SYSV_ABI __inet_ntop(); +int PS4_SYSV_ABI __inet_pton(); +int PS4_SYSV_ABI __progname(); +int PS4_SYSV_ABI __pthread_cleanup_pop_imp(); +int PS4_SYSV_ABI __pthread_cleanup_push_imp(); +int PS4_SYSV_ABI __pthread_cxa_finalize(); +int PS4_SYSV_ABI __sceKernelGetGPI(); +int PS4_SYSV_ABI __stack_chk_fail(); +int PS4_SYSV_ABI __stack_chk_guard(); +int PS4_SYSV_ABI __sys_debug_init(); +int PS4_SYSV_ABI __sys_dl_get_info(); +int PS4_SYSV_ABI __sys_dl_get_list(); +int PS4_SYSV_ABI __sys_dl_get_metadata(); +int PS4_SYSV_ABI __sys_dynlib_get_info_for_libdbg(); +int PS4_SYSV_ABI __sys_dynlib_get_info2(); +int PS4_SYSV_ABI __sys_dynlib_get_list_for_libdbg(); +int PS4_SYSV_ABI __sys_dynlib_get_list2(); +int PS4_SYSV_ABI __sys_dynlib_load_prx(); +int PS4_SYSV_ABI __sys_get_proc_type_info(); +int PS4_SYSV_ABI __sys_is_development_mode(); +int PS4_SYSV_ABI __sys_kqueueex(); +int PS4_SYSV_ABI __sys_namedobj_create(); +int PS4_SYSV_ABI __sys_namedobj_delete(); +int PS4_SYSV_ABI __sys_netabort(); +int PS4_SYSV_ABI __sys_netcontrol(); +int PS4_SYSV_ABI __sys_netgetiflist(); +int PS4_SYSV_ABI __sys_netgetsockinfo(); +int PS4_SYSV_ABI __sys_opmc_disable(); +int PS4_SYSV_ABI __sys_opmc_enable(); +int PS4_SYSV_ABI __sys_opmc_get_ctr(); +int PS4_SYSV_ABI __sys_opmc_get_hw(); +int PS4_SYSV_ABI __sys_opmc_set_ctl(); +int PS4_SYSV_ABI __sys_opmc_set_ctr(); +int PS4_SYSV_ABI __sys_opmc_set_hw(); +int PS4_SYSV_ABI __sys_osem_close(); +int PS4_SYSV_ABI __sys_osem_open(); +int PS4_SYSV_ABI __sys_randomized_path(); +int PS4_SYSV_ABI __sys_rdup(); +int PS4_SYSV_ABI __sys_regmgr_call(); +int PS4_SYSV_ABI __sys_set_uevt(); +int PS4_SYSV_ABI __sys_socketclose(); +int PS4_SYSV_ABI __sys_socketex(); +int PS4_SYSV_ABI __sys_test_debug_rwmem(); +int PS4_SYSV_ABI __sys_workaround8849(); +int PS4_SYSV_ABI __tls_get_addr(); +int PS4_SYSV_ABI __Ux86_64_setcontext(); +int PS4_SYSV_ABI _accept(); +int PS4_SYSV_ABI _bind(); +int PS4_SYSV_ABI _close(); +int PS4_SYSV_ABI _connect(); +int PS4_SYSV_ABI _dup2(); +int PS4_SYSV_ABI _execve(); +int PS4_SYSV_ABI _execvpe(); +int PS4_SYSV_ABI _exit(); +int PS4_SYSV_ABI _fcntl(); +int PS4_SYSV_ABI _fpathconf(); +int PS4_SYSV_ABI _fstat(); +int PS4_SYSV_ABI _fstatfs(); +int PS4_SYSV_ABI _getdirentries(); +int PS4_SYSV_ABI _getpeername(); +int PS4_SYSV_ABI _getsockname(); +int PS4_SYSV_ABI _getsockopt(); +int PS4_SYSV_ABI _ioctl(); +int PS4_SYSV_ABI _is_signal_return(); +int PS4_SYSV_ABI _listen(); +int PS4_SYSV_ABI _nanosleep(); +int PS4_SYSV_ABI _open(); +int PS4_SYSV_ABI _openat(); +int PS4_SYSV_ABI _read(); +int PS4_SYSV_ABI _readv(); +int PS4_SYSV_ABI _recvfrom(); +int PS4_SYSV_ABI _recvmsg(); +int PS4_SYSV_ABI _sceKernelRtldSetApplicationHeapAPI(); +int PS4_SYSV_ABI _sceKernelRtldThreadAtexitDecrement(); +int PS4_SYSV_ABI _sceKernelRtldThreadAtexitIncrement(); +int PS4_SYSV_ABI _sceKernelSetThreadAtexitCount(); +int PS4_SYSV_ABI _sceKernelSetThreadAtexitReport(); +int PS4_SYSV_ABI _sceKernelSetThreadDtors(); +int PS4_SYSV_ABI _sendmsg(); +int PS4_SYSV_ABI _sendto(); +int PS4_SYSV_ABI _setsockopt(); +int PS4_SYSV_ABI _sigaction(); +int PS4_SYSV_ABI _sigintr(); +int PS4_SYSV_ABI _sigprocmask(); +int PS4_SYSV_ABI _sigsuspend(); +int PS4_SYSV_ABI _umtx_op(); +int PS4_SYSV_ABI _wait4(); +int PS4_SYSV_ABI _write(); +int PS4_SYSV_ABI _writev(); +int PS4_SYSV_ABI accept(); +int PS4_SYSV_ABI access(); +int PS4_SYSV_ABI amd64_set_fsbase(); +int PS4_SYSV_ABI bind(); +int PS4_SYSV_ABI blockpool_batch(); +int PS4_SYSV_ABI blockpool_map(); +int PS4_SYSV_ABI blockpool_open(); +int PS4_SYSV_ABI blockpool_unmap(); +int PS4_SYSV_ABI chdir(); +int PS4_SYSV_ABI chflags(); +int PS4_SYSV_ABI chmod(); +int PS4_SYSV_ABI clock_getres(); +int PS4_SYSV_ABI clock_gettime(); +int PS4_SYSV_ABI clock_settime(); +int PS4_SYSV_ABI close(); +int PS4_SYSV_ABI connect(); +int PS4_SYSV_ABI cpuset_getaffinity(); +int PS4_SYSV_ABI cpuset_getid(); +int PS4_SYSV_ABI cpuset_setaffinity(); +int PS4_SYSV_ABI creat(); +int PS4_SYSV_ABI dlclose(); +int PS4_SYSV_ABI dlerror(); +int PS4_SYSV_ABI dlopen(); +int PS4_SYSV_ABI dlsym(); +int PS4_SYSV_ABI dup(); +int PS4_SYSV_ABI dup2(); +int PS4_SYSV_ABI dynlib_get_obj_member(); +int PS4_SYSV_ABI ps4_environ(); +int PS4_SYSV_ABI ps4_errno(); +int PS4_SYSV_ABI execv(); +int PS4_SYSV_ABI execve(); +int PS4_SYSV_ABI execvp(); +int PS4_SYSV_ABI fchflags(); +int PS4_SYSV_ABI fchmod(); +int PS4_SYSV_ABI fcntl(); +int PS4_SYSV_ABI fdatasync(); +int PS4_SYSV_ABI flock(); +int PS4_SYSV_ABI fstat(); +int PS4_SYSV_ABI fsync(); +int PS4_SYSV_ABI ftruncate(); +int PS4_SYSV_ABI futimes(); +int PS4_SYSV_ABI get_authinfo(); +int PS4_SYSV_ABI get_module_info_list(); +int PS4_SYSV_ABI get_page_table_stats(); +int PS4_SYSV_ABI get_sdk_compiled_version(); +int PS4_SYSV_ABI get_self_auth_info(); +int PS4_SYSV_ABI get_vm_map_timestamp(); +int PS4_SYSV_ABI getargc(); +int PS4_SYSV_ABI getargv(); +int PS4_SYSV_ABI getcontext(); +int PS4_SYSV_ABI getdents(); +int PS4_SYSV_ABI getdirentries(); +int PS4_SYSV_ABI getdtablesize(); +int PS4_SYSV_ABI getegid(); +int PS4_SYSV_ABI geteuid(); +int PS4_SYSV_ABI getgid(); +int PS4_SYSV_ABI getgroups(); +int PS4_SYSV_ABI getitimer(); +int PS4_SYSV_ABI getlogin(); +int PS4_SYSV_ABI getlogin_r(); +int PS4_SYSV_ABI getpagesize(); +int PS4_SYSV_ABI getpeername(); +int PS4_SYSV_ABI getpid(); +int PS4_SYSV_ABI getppid(); +int PS4_SYSV_ABI getpriority(); +int PS4_SYSV_ABI getrlimit(); +int PS4_SYSV_ABI getrusage(); +int PS4_SYSV_ABI getsid(); +int PS4_SYSV_ABI getsockname(); +int PS4_SYSV_ABI getsockopt(); +int PS4_SYSV_ABI gettimeofday(); +int PS4_SYSV_ABI getuid(); +int PS4_SYSV_ABI htonl(); +int PS4_SYSV_ABI htons(); +int PS4_SYSV_ABI inet_ntop(); +int PS4_SYSV_ABI inet_pton(); +int PS4_SYSV_ABI ioctl(); +int PS4_SYSV_ABI ipmimgr_call(); +int PS4_SYSV_ABI is_in_sandbox(); +int PS4_SYSV_ABI issetugid(); +int PS4_SYSV_ABI kevent(); +int PS4_SYSV_ABI kill(); +int PS4_SYSV_ABI kqueue(); +int PS4_SYSV_ABI ksem_close(); +int PS4_SYSV_ABI ksem_destroy(); +int PS4_SYSV_ABI ksem_getvalue(); +int PS4_SYSV_ABI ksem_init(); +int PS4_SYSV_ABI ksem_open(); +int PS4_SYSV_ABI ksem_post(); +int PS4_SYSV_ABI ksem_timedwait(); +int PS4_SYSV_ABI ksem_trywait(); +int PS4_SYSV_ABI ksem_unlink(); +int PS4_SYSV_ABI ksem_wait(); +int PS4_SYSV_ABI ktimer_create(); +int PS4_SYSV_ABI ktimer_delete(); +int PS4_SYSV_ABI ktimer_getoverrun(); +int PS4_SYSV_ABI ktimer_gettime(); +int PS4_SYSV_ABI ktimer_settime(); +int PS4_SYSV_ABI listen(); +int PS4_SYSV_ABI lseek(); +int PS4_SYSV_ABI lstat(); +int PS4_SYSV_ABI madvise(); +int PS4_SYSV_ABI mdbg_service(); +int PS4_SYSV_ABI mincore(); +int PS4_SYSV_ABI mkdir(); +int PS4_SYSV_ABI mlock(); +int PS4_SYSV_ABI mlockall(); +int PS4_SYSV_ABI mmap(); +int PS4_SYSV_ABI mprotect(); +int PS4_SYSV_ABI msync(); +int PS4_SYSV_ABI munlock(); +int PS4_SYSV_ABI munlockall(); +int PS4_SYSV_ABI munmap(); +int PS4_SYSV_ABI nanosleep(); +int PS4_SYSV_ABI ntohl(); +int PS4_SYSV_ABI ntohs(); +int PS4_SYSV_ABI open(); +int PS4_SYSV_ABI pause(); +int PS4_SYSV_ABI physhm_open(); +int PS4_SYSV_ABI physhm_unlink(); +int PS4_SYSV_ABI pipe(); +int PS4_SYSV_ABI poll(); +int PS4_SYSV_ABI pread(); +int PS4_SYSV_ABI preadv(); +int PS4_SYSV_ABI profil(); +int PS4_SYSV_ABI pselect(); +int PS4_SYSV_ABI pthread_atfork(); +int PS4_SYSV_ABI pthread_attr_destroy(); +int PS4_SYSV_ABI pthread_attr_get_np(); +int PS4_SYSV_ABI pthread_attr_getaffinity_np(); +int PS4_SYSV_ABI pthread_attr_getdetachstate(); +int PS4_SYSV_ABI pthread_attr_getguardsize(); +int PS4_SYSV_ABI pthread_attr_getinheritsched(); +int PS4_SYSV_ABI pthread_attr_getschedparam(); +int PS4_SYSV_ABI pthread_attr_getschedpolicy(); +int PS4_SYSV_ABI pthread_attr_getscope(); +int PS4_SYSV_ABI pthread_attr_getstack(); +int PS4_SYSV_ABI pthread_attr_getstackaddr(); +int PS4_SYSV_ABI pthread_attr_getstacksize(); +int PS4_SYSV_ABI pthread_attr_init(); +int PS4_SYSV_ABI pthread_attr_setaffinity_np(); +int PS4_SYSV_ABI pthread_attr_setcreatesuspend_np(); +int PS4_SYSV_ABI pthread_attr_setdetachstate(); +int PS4_SYSV_ABI pthread_attr_setguardsize(); +int PS4_SYSV_ABI pthread_attr_setinheritsched(); +int PS4_SYSV_ABI pthread_attr_setschedparam(); +int PS4_SYSV_ABI pthread_attr_setschedpolicy(); +int PS4_SYSV_ABI pthread_attr_setscope(); +int PS4_SYSV_ABI pthread_attr_setstack(); +int PS4_SYSV_ABI pthread_attr_setstackaddr(); +int PS4_SYSV_ABI pthread_attr_setstacksize(); +int PS4_SYSV_ABI pthread_barrier_destroy(); +int PS4_SYSV_ABI pthread_barrier_init(); +int PS4_SYSV_ABI pthread_barrier_setname_np(); +int PS4_SYSV_ABI pthread_barrier_wait(); +int PS4_SYSV_ABI pthread_barrierattr_destroy(); +int PS4_SYSV_ABI pthread_barrierattr_getpshared(); +int PS4_SYSV_ABI pthread_barrierattr_init(); +int PS4_SYSV_ABI pthread_barrierattr_setpshared(); +int PS4_SYSV_ABI pthread_cancel(); +int PS4_SYSV_ABI pthread_cleanup_pop(); +int PS4_SYSV_ABI pthread_cleanup_push(); +int PS4_SYSV_ABI pthread_cond_broadcast(); +int PS4_SYSV_ABI pthread_cond_destroy(); +int PS4_SYSV_ABI pthread_cond_init(); +int PS4_SYSV_ABI pthread_cond_reltimedwait_np(); +int PS4_SYSV_ABI pthread_cond_setname_np(); +int PS4_SYSV_ABI pthread_cond_signal(); +int PS4_SYSV_ABI pthread_cond_signalto_np(); +int PS4_SYSV_ABI pthread_cond_timedwait(); +int PS4_SYSV_ABI pthread_cond_wait(); +int PS4_SYSV_ABI pthread_condattr_destroy(); +int PS4_SYSV_ABI pthread_condattr_getclock(); +int PS4_SYSV_ABI pthread_condattr_getpshared(); +int PS4_SYSV_ABI pthread_condattr_init(); +int PS4_SYSV_ABI pthread_condattr_setclock(); +int PS4_SYSV_ABI pthread_condattr_setpshared(); +int PS4_SYSV_ABI pthread_create(); +int PS4_SYSV_ABI pthread_create_name_np(); +int PS4_SYSV_ABI pthread_detach(); +int PS4_SYSV_ABI pthread_equal(); +int PS4_SYSV_ABI pthread_exit(); +int PS4_SYSV_ABI pthread_get_specificarray_np(); +int PS4_SYSV_ABI pthread_get_user_context_np(); +int PS4_SYSV_ABI pthread_getaffinity_np(); +int PS4_SYSV_ABI pthread_getconcurrency(); +int PS4_SYSV_ABI pthread_getcpuclockid(); +int PS4_SYSV_ABI pthread_getname_np(); +int PS4_SYSV_ABI pthread_getprio(); +int PS4_SYSV_ABI pthread_getschedparam(); +int PS4_SYSV_ABI pthread_getspecific(); +int PS4_SYSV_ABI pthread_getstack_np(); +int PS4_SYSV_ABI pthread_getthreadid_np(); +int PS4_SYSV_ABI pthread_join(); +int PS4_SYSV_ABI pthread_key_create(); +int PS4_SYSV_ABI pthread_key_delete(); +int PS4_SYSV_ABI pthread_kill(); +int PS4_SYSV_ABI pthread_main_np(); +int PS4_SYSV_ABI pthread_multi_np(); +int PS4_SYSV_ABI pthread_mutex_destroy(); +int PS4_SYSV_ABI pthread_mutex_getprioceiling(); +int PS4_SYSV_ABI pthread_mutex_getspinloops_np(); +int PS4_SYSV_ABI pthread_mutex_getyieldloops_np(); +int PS4_SYSV_ABI pthread_mutex_init(); +int PS4_SYSV_ABI pthread_mutex_init_for_mono(); +int PS4_SYSV_ABI pthread_mutex_isowned_np(); +int PS4_SYSV_ABI pthread_mutex_lock(); +int PS4_SYSV_ABI pthread_mutex_reltimedlock_np(); +int PS4_SYSV_ABI pthread_mutex_setname_np(); +int PS4_SYSV_ABI pthread_mutex_setprioceiling(); +int PS4_SYSV_ABI pthread_mutex_setspinloops_np(); +int PS4_SYSV_ABI pthread_mutex_setyieldloops_np(); +int PS4_SYSV_ABI pthread_mutex_timedlock(); +int PS4_SYSV_ABI pthread_mutex_trylock(); +int PS4_SYSV_ABI pthread_mutex_unlock(); +int PS4_SYSV_ABI pthread_mutexattr_destroy(); +int PS4_SYSV_ABI pthread_mutexattr_getkind_np(); +int PS4_SYSV_ABI pthread_mutexattr_getprioceiling(); +int PS4_SYSV_ABI pthread_mutexattr_getprotocol(); +int PS4_SYSV_ABI pthread_mutexattr_getpshared(); +int PS4_SYSV_ABI pthread_mutexattr_gettype(); +int PS4_SYSV_ABI pthread_mutexattr_init(); +int PS4_SYSV_ABI pthread_mutexattr_setkind_np(); +int PS4_SYSV_ABI pthread_mutexattr_setprioceiling(); +int PS4_SYSV_ABI pthread_mutexattr_setprotocol(); +int PS4_SYSV_ABI pthread_mutexattr_setpshared(); +int PS4_SYSV_ABI pthread_mutexattr_settype(); +int PS4_SYSV_ABI pthread_once(); +int PS4_SYSV_ABI pthread_rename_np(); +int PS4_SYSV_ABI pthread_resume_all_np(); +int PS4_SYSV_ABI pthread_resume_np(); +int PS4_SYSV_ABI pthread_resume_user_context_np(); +int PS4_SYSV_ABI pthread_rwlock_destroy(); +int PS4_SYSV_ABI pthread_rwlock_init(); +int PS4_SYSV_ABI pthread_rwlock_rdlock(); +int PS4_SYSV_ABI pthread_rwlock_reltimedrdlock_np(); +int PS4_SYSV_ABI pthread_rwlock_reltimedwrlock_np(); +int PS4_SYSV_ABI pthread_rwlock_setname_np(); +int PS4_SYSV_ABI pthread_rwlock_timedrdlock(); +int PS4_SYSV_ABI pthread_rwlock_timedwrlock(); +int PS4_SYSV_ABI pthread_rwlock_tryrdlock(); +int PS4_SYSV_ABI pthread_rwlock_trywrlock(); +int PS4_SYSV_ABI pthread_rwlock_unlock(); +int PS4_SYSV_ABI pthread_rwlock_wrlock(); +int PS4_SYSV_ABI pthread_rwlockattr_destroy(); +int PS4_SYSV_ABI pthread_rwlockattr_getpshared(); +int PS4_SYSV_ABI pthread_rwlockattr_gettype_np(); +int PS4_SYSV_ABI pthread_rwlockattr_init(); +int PS4_SYSV_ABI pthread_rwlockattr_setpshared(); +int PS4_SYSV_ABI pthread_rwlockattr_settype_np(); +int PS4_SYSV_ABI pthread_self(); +int PS4_SYSV_ABI pthread_set_defaultstacksize_np(); +int PS4_SYSV_ABI pthread_set_name_np(); +int PS4_SYSV_ABI pthread_set_user_context_np(); +int PS4_SYSV_ABI pthread_setaffinity_np(); +int PS4_SYSV_ABI pthread_setcancelstate(); +int PS4_SYSV_ABI pthread_setcanceltype(); +int PS4_SYSV_ABI pthread_setconcurrency(); +int PS4_SYSV_ABI pthread_setprio(); +int PS4_SYSV_ABI pthread_setschedparam(); +int PS4_SYSV_ABI pthread_setspecific(); +int PS4_SYSV_ABI pthread_sigmask(); +int PS4_SYSV_ABI pthread_single_np(); +int PS4_SYSV_ABI pthread_spin_destroy(); +int PS4_SYSV_ABI pthread_spin_init(); +int PS4_SYSV_ABI pthread_spin_lock(); +int PS4_SYSV_ABI pthread_spin_trylock(); +int PS4_SYSV_ABI pthread_spin_unlock(); +int PS4_SYSV_ABI pthread_suspend_all_np(); +int PS4_SYSV_ABI pthread_suspend_np(); +int PS4_SYSV_ABI pthread_suspend_user_context_np(); +int PS4_SYSV_ABI pthread_switch_add_np(); +int PS4_SYSV_ABI pthread_switch_delete_np(); +int PS4_SYSV_ABI pthread_testcancel(); +int PS4_SYSV_ABI pthread_timedjoin_np(); +int PS4_SYSV_ABI pthread_yield(); +int PS4_SYSV_ABI pwrite(); +int PS4_SYSV_ABI pwritev(); +int PS4_SYSV_ABI raise(); +int PS4_SYSV_ABI read(); +int PS4_SYSV_ABI readv(); +int PS4_SYSV_ABI recv(); +int PS4_SYSV_ABI recvfrom(); +int PS4_SYSV_ABI recvmsg(); +int PS4_SYSV_ABI rename(); +int PS4_SYSV_ABI rfork_thread(); +int PS4_SYSV_ABI rmdir(); +int PS4_SYSV_ABI rtld_printf(); +int PS4_SYSV_ABI rtprio_thread(); +int PS4_SYSV_ABI sceKernelAddCpumodeEvent(); +int PS4_SYSV_ABI sceKernelAddFileEvent(); +int PS4_SYSV_ABI sceKernelAddGpuExceptionEvent(); +int PS4_SYSV_ABI sceKernelAddHRTimerEvent(); +int PS4_SYSV_ABI sceKernelAddReadEvent(); +int PS4_SYSV_ABI sceKernelAddTimerEvent(); +int PS4_SYSV_ABI sceKernelAddUserEvent(); +int PS4_SYSV_ABI sceKernelAddUserEventEdge(); +int PS4_SYSV_ABI sceKernelAddWriteEvent(); +int PS4_SYSV_ABI sceKernelAioCancelRequest(); +int PS4_SYSV_ABI sceKernelAioCancelRequests(); +int PS4_SYSV_ABI sceKernelAioDeleteRequest(); +int PS4_SYSV_ABI sceKernelAioDeleteRequests(); +int PS4_SYSV_ABI sceKernelAioInitializeImpl(); +int PS4_SYSV_ABI sceKernelAioInitializeParam(); +int PS4_SYSV_ABI sceKernelAioPollRequest(); +int PS4_SYSV_ABI sceKernelAioPollRequests(); +int PS4_SYSV_ABI sceKernelAioSetParam(); +int PS4_SYSV_ABI sceKernelAioSubmitReadCommands(); +int PS4_SYSV_ABI sceKernelAioSubmitReadCommandsMultiple(); +int PS4_SYSV_ABI sceKernelAioSubmitWriteCommands(); +int PS4_SYSV_ABI sceKernelAioSubmitWriteCommandsMultiple(); +int PS4_SYSV_ABI sceKernelAioWaitRequest(); +int PS4_SYSV_ABI sceKernelAioWaitRequests(); +int PS4_SYSV_ABI sceKernelAllocateDirectMemory(); +int PS4_SYSV_ABI sceKernelAllocateDirectMemoryForMiniApp(); +int PS4_SYSV_ABI sceKernelAllocateMainDirectMemory(); +int PS4_SYSV_ABI sceKernelAllocateTraceDirectMemory(); +int PS4_SYSV_ABI sceKernelAvailableDirectMemorySize(); +int PS4_SYSV_ABI sceKernelAvailableFlexibleMemorySize(); +int PS4_SYSV_ABI sceKernelBacktraceSelf(); +int PS4_SYSV_ABI sceKernelBatchMap(); +int PS4_SYSV_ABI sceKernelBatchMap2(); +int PS4_SYSV_ABI sceKernelCancelEventFlag(); +int PS4_SYSV_ABI sceKernelCancelSema(); +int PS4_SYSV_ABI sceKernelCheckedReleaseDirectMemory(); +int PS4_SYSV_ABI sceKernelCheckReachability(); +int PS4_SYSV_ABI sceKernelChmod(); +int PS4_SYSV_ABI sceKernelClearBootReqNotifyCount(); +int PS4_SYSV_ABI sceKernelClearEventFlag(); +int PS4_SYSV_ABI sceKernelClearGameDirectMemory(); +int PS4_SYSV_ABI sceKernelClockGetres(); +int PS4_SYSV_ABI sceKernelClockGettime(); +int PS4_SYSV_ABI sceKernelClose(); +int PS4_SYSV_ABI sceKernelCloseEport(); +int PS4_SYSV_ABI sceKernelCloseEventFlag(); +int PS4_SYSV_ABI sceKernelCloseSema(); +int PS4_SYSV_ABI sceKernelConfiguredFlexibleMemorySize(); +int PS4_SYSV_ABI sceKernelConvertLocaltimeToUtc(); +int PS4_SYSV_ABI sceKernelConvertUtcToLocaltime(); +int PS4_SYSV_ABI sceKernelCreateEport(); +int PS4_SYSV_ABI sceKernelCreateEqueue(); +int PS4_SYSV_ABI sceKernelCreateEventFlag(); +int PS4_SYSV_ABI sceKernelCreateSema(); +int PS4_SYSV_ABI sceKernelDebugAcquireAndUpdateDebugRegister(); +int PS4_SYSV_ABI sceKernelDebugGetAppStatus(); +int PS4_SYSV_ABI sceKernelDebugGetPauseCount(); +int PS4_SYSV_ABI sceKernelDebugGpuPaDebugIsInProgress(); +int PS4_SYSV_ABI sceKernelDebugOutText(); +int PS4_SYSV_ABI sceKernelDebugRaiseException(); +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionOnReleaseMode(); +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionWithContext(); +int PS4_SYSV_ABI sceKernelDebugRaiseExceptionWithInfo(); +int PS4_SYSV_ABI sceKernelDebugReleaseDebugContext(); +int PS4_SYSV_ABI sceKernelDeleteCpumodeEvent(); +int PS4_SYSV_ABI sceKernelDeleteEport(); +int PS4_SYSV_ABI sceKernelDeleteEqueue(); +int PS4_SYSV_ABI sceKernelDeleteEventFlag(); +int PS4_SYSV_ABI sceKernelDeleteFileEvent(); +int PS4_SYSV_ABI sceKernelDeleteGpuExceptionEvent(); +int PS4_SYSV_ABI sceKernelDeleteHRTimerEvent(); +int PS4_SYSV_ABI sceKernelDeleteReadEvent(); +int PS4_SYSV_ABI sceKernelDeleteSema(); +int PS4_SYSV_ABI sceKernelDeleteTimerEvent(); +int PS4_SYSV_ABI sceKernelDeleteUserEvent(); +int PS4_SYSV_ABI sceKernelDeleteWriteEvent(); +int PS4_SYSV_ABI sceKernelDirectMemoryQuery(); +int PS4_SYSV_ABI sceKernelDirectMemoryQueryForId(); +int PS4_SYSV_ABI sceKernelDlsym(); +int PS4_SYSV_ABI sceKernelEnableDmemAliasing(); +int PS4_SYSV_ABI sceKernelEnableDmemAliasing2(); +int PS4_SYSV_ABI sceKernelEnablePthreadObjectCheck(); +int PS4_SYSV_ABI sceKernelError(); +int PS4_SYSV_ABI sceKernelEventLogInit(); +int PS4_SYSV_ABI sceKernelEventLogPread(); +int PS4_SYSV_ABI sceKernelEventLogRead(); +int PS4_SYSV_ABI sceKernelEventLogWrite(); +int PS4_SYSV_ABI sceKernelFchmod(); +int PS4_SYSV_ABI sceKernelFcntl(); +int PS4_SYSV_ABI sceKernelFdatasync(); +int PS4_SYSV_ABI sceKernelFlock(); +int PS4_SYSV_ABI sceKernelFstat(); +int PS4_SYSV_ABI sceKernelFsync(); +int PS4_SYSV_ABI sceKernelFtruncate(); +int PS4_SYSV_ABI sceKernelFutimes(); +int PS4_SYSV_ABI sceKernelGetAllowedSdkVersionOnSystem(); +int PS4_SYSV_ABI sceKernelGetAppInfo(); +int PS4_SYSV_ABI sceKernelGetAslrStatus(); +int PS4_SYSV_ABI sceKernelGetBackupRestoreMode(); +int PS4_SYSV_ABI sceKernelGetBackupRestoreModeOfNextBoot(); +int PS4_SYSV_ABI sceKernelGetBasicProductShape(); +int PS4_SYSV_ABI sceKernelGetBetaUpdateTestForRcmgr(); +int PS4_SYSV_ABI sceKernelGetBioUsageAll(); +int PS4_SYSV_ABI sceKernelGetBootReqNotifyCount(); +int PS4_SYSV_ABI sceKernelGetCallRecord(); +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersion(); +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersionByPath(); +int PS4_SYSV_ABI sceKernelGetCompiledSdkVersionByPid(); +int PS4_SYSV_ABI sceKernelGetCpuFrequency(); +int PS4_SYSV_ABI sceKernelGetCpumode(); +int PS4_SYSV_ABI sceKernelGetCpumodeGame(); +int PS4_SYSV_ABI sceKernelGetCpuTemperature(); +int PS4_SYSV_ABI sceKernelGetCpuUsage(); +int PS4_SYSV_ABI sceKernelGetCpuUsageAll(); +int PS4_SYSV_ABI sceKernelGetCpuUsageProc(); +int PS4_SYSV_ABI sceKernelGetCpuUsageProc2(); +int PS4_SYSV_ABI sceKernelGetCpuUsageThread(); +int PS4_SYSV_ABI sceKernelGetCurrentCpu(); +int PS4_SYSV_ABI sceKernelGetDataTransferMode(); +int PS4_SYSV_ABI sceKernelGetDebugMenuMiniModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetDebugMenuModeForPsmForRcmgr(); +int PS4_SYSV_ABI sceKernelGetDebugMenuModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetdents(); +int PS4_SYSV_ABI sceKernelGetDirectMemorySize(); +int PS4_SYSV_ABI sceKernelGetDirectMemoryType(); +int PS4_SYSV_ABI sceKernelGetdirentries(); +int PS4_SYSV_ABI sceKernelGetEventData(); +int PS4_SYSV_ABI sceKernelGetEventError(); +int PS4_SYSV_ABI sceKernelGetEventFflags(); +int PS4_SYSV_ABI sceKernelGetEventFilter(); +int PS4_SYSV_ABI sceKernelGetEventId(); +int PS4_SYSV_ABI sceKernelGetEventUserData(); +int PS4_SYSV_ABI sceKernelGetExecutableModuleHandle(); +int PS4_SYSV_ABI sceKernelGetExtLibcHandle(); +int PS4_SYSV_ABI sceKernelGetFakeFinalizeMenuForRcmgr(); +int PS4_SYSV_ABI sceKernelGetFlagedUpdaterForRcmgr(); +int PS4_SYSV_ABI sceKernelGetForceUpdateModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetFsSandboxRandomWord(); +int PS4_SYSV_ABI sceKernelGetGPI(); +int PS4_SYSV_ABI sceKernelGetGPO(); +int PS4_SYSV_ABI sceKernelGetHwFeatureInfoForDecid(); +int PS4_SYSV_ABI sceKernelGetIdPs(); +int PS4_SYSV_ABI sceKernelGetIdTableCurrentCount(); +int PS4_SYSV_ABI sceKernelGetIpcPath(); +int PS4_SYSV_ABI sceKernelGetLibkernelTextLocation(); +int PS4_SYSV_ABI sceKernelGetMainSocId(); +int PS4_SYSV_ABI sceKernelGetModuleInfo(); +int PS4_SYSV_ABI sceKernelGetModuleInfoForUnwind(); +int PS4_SYSV_ABI sceKernelGetModuleInfoFromAddr(); +int PS4_SYSV_ABI sceKernelGetModuleInfoInternal(); +int PS4_SYSV_ABI sceKernelGetModuleList(); +int PS4_SYSV_ABI sceKernelGetModuleListInternal(); +int PS4_SYSV_ABI sceKernelGetOpenPsIdForSystem(); +int PS4_SYSV_ABI sceKernelGetPageTableStats(); +int PS4_SYSV_ABI sceKernelGetPagingStatsOfAllObjects(); +int PS4_SYSV_ABI sceKernelGetPagingStatsOfAllThreads(); +int PS4_SYSV_ABI sceKernelGetPhysPageSize(); +int PS4_SYSV_ABI sceKernelGetProcessName(); +int PS4_SYSV_ABI sceKernelGetProcessTime(); +int PS4_SYSV_ABI sceKernelGetProcessTimeCounter(); +int PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency(); +int PS4_SYSV_ABI sceKernelGetProcessType(); +int PS4_SYSV_ABI sceKernelGetProcParam(); +int PS4_SYSV_ABI sceKernelGetProductCode(); +int PS4_SYSV_ABI sceKernelGetProductStr(); +int PS4_SYSV_ABI sceKernelGetPrtAperture(); +int PS4_SYSV_ABI sceKernelGetPsmIntdevModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetPsnAccessTraceLogForRcmgr(); +int PS4_SYSV_ABI sceKernelGetQafExpirationTimeNotafterForRcmgr(); +int PS4_SYSV_ABI sceKernelGetQafExpirationTimeNotbeforeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetQafGenerationForRcmgr(); +int PS4_SYSV_ABI sceKernelGetQafNameForRcmgr(); +int PS4_SYSV_ABI sceKernelGetRenderingMode(); +int PS4_SYSV_ABI sceKernelGetResidentCount(); +int PS4_SYSV_ABI sceKernelGetResidentFmemCount(); +int PS4_SYSV_ABI sceKernelGetSafemode(); +int PS4_SYSV_ABI sceKernelGetSanitizerMallocReplace(); +int PS4_SYSV_ABI sceKernelGetSanitizerMallocReplaceExternal(); +int PS4_SYSV_ABI sceKernelGetSanitizerNewReplace(); +int PS4_SYSV_ABI sceKernelGetSanitizerNewReplaceExternal(); +int PS4_SYSV_ABI sceKernelGetSocPowerConsumption(); +int PS4_SYSV_ABI sceKernelGetSocSensorTemperature(); +int PS4_SYSV_ABI sceKernelGetSpecialIForRcmgr(); +int PS4_SYSV_ABI sceKernelGetSubsysId(); +int PS4_SYSV_ABI sceKernelGetSystemExVersion(); +int PS4_SYSV_ABI sceKernelGetSystemLevelDebuggerModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetSystemSwBeta(); +int PS4_SYSV_ABI sceKernelGetSystemSwVersion(); +int PS4_SYSV_ABI sceKernelGetThreadName(); +int PS4_SYSV_ABI sceKernelGettimeofday(); +int PS4_SYSV_ABI sceKernelGettimezone(); +int PS4_SYSV_ABI sceKernelGetTraceMemoryStats(); +int PS4_SYSV_ABI sceKernelGetTscFrequency(); +int PS4_SYSV_ABI sceKernelGetUtokenDataExecutionForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenExpirationTimeNotafterForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenExpirationTimeNotbeforeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenFakeSharefactoryForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenFlagedUpdaterForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenNpEnvSwitchingForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenSaveDataRepairForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenStoreModeForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenUseSoftwagnerForAcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenUseSoftwagnerForRcmgr(); +int PS4_SYSV_ABI sceKernelGetUtokenWeakenedPortRestrictionForRcmgr(); +int PS4_SYSV_ABI sceKernelGetVrCaptureSize(); +int PS4_SYSV_ABI sceKernelHasNeoMode(); +int PS4_SYSV_ABI sceKernelHwHasOpticalOut(); +int PS4_SYSV_ABI sceKernelHwHasWlanBt(); +int PS4_SYSV_ABI sceKernelIccControlBDPowerState(); +int PS4_SYSV_ABI sceKernelIccControlUSBPowerState(); +int PS4_SYSV_ABI sceKernelIccGetBDPowerState(); +int PS4_SYSV_ABI sceKernelIccGetCountTime(); +int PS4_SYSV_ABI sceKernelIccGetCPMode(); +int PS4_SYSV_ABI sceKernelIccGetCpuInfoBit(); +int PS4_SYSV_ABI sceKernelIccGetErrLog(); +int PS4_SYSV_ABI sceKernelIccGetHwInfo(); +int PS4_SYSV_ABI sceKernelIccGetPowerNumberOfBootShutdown(); +int PS4_SYSV_ABI sceKernelIccGetPowerOperatingTime(); +int PS4_SYSV_ABI sceKernelIccGetPowerUpCause(); +int PS4_SYSV_ABI sceKernelIccGetSysEventLog(); +int PS4_SYSV_ABI sceKernelIccGetThermalAlert(); +int PS4_SYSV_ABI sceKernelIccGetUSBPowerState(); +int PS4_SYSV_ABI sceKernelIccIndicatorBootDone(); +int PS4_SYSV_ABI sceKernelIccIndicatorShutdown(); +int PS4_SYSV_ABI sceKernelIccIndicatorStandby(); +int PS4_SYSV_ABI sceKernelIccIndicatorStandbyBoot(); +int PS4_SYSV_ABI sceKernelIccIndicatorStandbyShutdown(); +int PS4_SYSV_ABI sceKernelIccNotifyBootStatus(); +int PS4_SYSV_ABI sceKernelIccNvsFlush(); +int PS4_SYSV_ABI sceKernelIccReadPowerBootMessage(); +int PS4_SYSV_ABI sceKernelIccSetBuzzer(); +int PS4_SYSV_ABI sceKernelIccSetCPMode(); +int PS4_SYSV_ABI sceKernelIccSetCpuInfoBit(); +int PS4_SYSV_ABI sceKernelIccSetDownloadMode(); +int PS4_SYSV_ABI sceKernelInstallExceptionHandler(); +int PS4_SYSV_ABI sceKernelInternalGetKmemStatistics(); +int PS4_SYSV_ABI sceKernelInternalGetMapStatistics(); +int PS4_SYSV_ABI sceKernelInternalHeapPrintBacktraceWithModuleInfo(); +int PS4_SYSV_ABI sceKernelInternalMapDirectMemory(); +int PS4_SYSV_ABI sceKernelInternalMapNamedDirectMemory(); +int PS4_SYSV_ABI sceKernelInternalMemoryGetAvailableSize(); +int PS4_SYSV_ABI sceKernelInternalMemoryGetModuleSegmentInfo(); +int PS4_SYSV_ABI sceKernelInternalResumeDirectMemoryRelease(); +int PS4_SYSV_ABI sceKernelInternalSuspendDirectMemoryRelease(); +int PS4_SYSV_ABI sceKernelIsAddressSanitizerEnabled(); +int PS4_SYSV_ABI sceKernelIsAllowedToSelectDvdRegion(); +int PS4_SYSV_ABI sceKernelIsAuthenticNeo(); +int PS4_SYSV_ABI sceKernelIsCEX(); +int PS4_SYSV_ABI sceKernelIsDebuggerAttached(); +int PS4_SYSV_ABI sceKernelIsDevKit(); +int PS4_SYSV_ABI sceKernelIsExperimentalBeta(); +int PS4_SYSV_ABI sceKernelIsGenuineCEX(); +int PS4_SYSV_ABI sceKernelIsGenuineDevKit(); +int PS4_SYSV_ABI sceKernelIsGenuineKratosCex(); +int PS4_SYSV_ABI sceKernelIsGenuineN(); +int PS4_SYSV_ABI sceKernelIsGenuineTestKit(); +int PS4_SYSV_ABI sceKernelIsInSandbox(); +int PS4_SYSV_ABI sceKernelIsKratos(); +int PS4_SYSV_ABI sceKernelIsMainOnStanbyMode(); +int PS4_SYSV_ABI sceKernelIsMainOnStandbyMode(); +int PS4_SYSV_ABI sceKernelIsNeoMode(); +int PS4_SYSV_ABI sceKernelIsStack(); +int PS4_SYSV_ABI sceKernelIsTestKit(); +int PS4_SYSV_ABI sceKernelJitCreateAliasOfSharedMemory(); +int PS4_SYSV_ABI sceKernelJitCreateSharedMemory(); +int PS4_SYSV_ABI sceKernelJitGetSharedMemoryInfo(); +int PS4_SYSV_ABI sceKernelJitMapSharedMemory(); +int PS4_SYSV_ABI sceKernelKernelHeapUsage(); +int PS4_SYSV_ABI sceKernelLoadStartModule(); +int PS4_SYSV_ABI sceKernelLoadStartModuleForSysmodule(); +int PS4_SYSV_ABI sceKernelLseek(); +int PS4_SYSV_ABI sceKernelLwfsAllocateBlock(); +int PS4_SYSV_ABI sceKernelLwfsLseek(); +int PS4_SYSV_ABI sceKernelLwfsSetAttribute(); +int PS4_SYSV_ABI sceKernelLwfsTrimBlock(); +int PS4_SYSV_ABI sceKernelLwfsWrite(); +int PS4_SYSV_ABI sceKernelMapDirectMemory(); +int PS4_SYSV_ABI sceKernelMapDirectMemory2(); +int PS4_SYSV_ABI sceKernelMapFlexibleMemory(); +int PS4_SYSV_ABI sceKernelMapNamedDirectMemory(); +int PS4_SYSV_ABI sceKernelMapNamedFlexibleMemory(); +int PS4_SYSV_ABI sceKernelMapNamedSystemFlexibleMemory(); +int PS4_SYSV_ABI sceKernelMapSanitizerShadowMemory(); +int PS4_SYSV_ABI sceKernelMapTraceMemory(); +int PS4_SYSV_ABI sceKernelMemoryPoolBatch(); +int PS4_SYSV_ABI sceKernelMemoryPoolCommit(); +int PS4_SYSV_ABI sceKernelMemoryPoolDecommit(); +int PS4_SYSV_ABI sceKernelMemoryPoolExpand(); +int PS4_SYSV_ABI sceKernelMemoryPoolGetBlockStats(); +int PS4_SYSV_ABI sceKernelMemoryPoolMove(); +int PS4_SYSV_ABI sceKernelMemoryPoolReserve(); +int PS4_SYSV_ABI sceKernelMkdir(); +int PS4_SYSV_ABI sceKernelMlock(); +int PS4_SYSV_ABI sceKernelMlockall(); +int PS4_SYSV_ABI sceKernelMmap(); +int PS4_SYSV_ABI sceKernelMprotect(); +int PS4_SYSV_ABI sceKernelMsync(); +int PS4_SYSV_ABI sceKernelMtypeprotect(); +int PS4_SYSV_ABI sceKernelMunlock(); +int PS4_SYSV_ABI sceKernelMunlockall(); +int PS4_SYSV_ABI sceKernelMunmap(); +int PS4_SYSV_ABI sceKernelNanosleep(); +int PS4_SYSV_ABI sceKernelNormalizePath(); +int PS4_SYSV_ABI sceKernelNotifyAppStateChanged(); +int PS4_SYSV_ABI sceKernelNotifySystemSuspendResumeProgress(); +int PS4_SYSV_ABI sceKernelNotifySystemSuspendStart(); +int PS4_SYSV_ABI sceKernelOpen(); +int PS4_SYSV_ABI sceKernelOpenEport(); +int PS4_SYSV_ABI sceKernelOpenEventFlag(); +int PS4_SYSV_ABI sceKernelOpenSema(); +int PS4_SYSV_ABI sceKernelPollEventFlag(); +int PS4_SYSV_ABI sceKernelPollSema(); +int PS4_SYSV_ABI sceKernelPread(); +int PS4_SYSV_ABI sceKernelPreadv(); +int PS4_SYSV_ABI sceKernelPrintBacktraceWithModuleInfo(); +int PS4_SYSV_ABI sceKernelProtectDirectMemory(); +int PS4_SYSV_ABI sceKernelProtectDirectMemoryForPID(); +int PS4_SYSV_ABI sceKernelPwrite(); +int PS4_SYSV_ABI sceKernelPwritev(); +int PS4_SYSV_ABI sceKernelQueryMemoryProtection(); +int PS4_SYSV_ABI sceKernelQueryTraceMemory(); +int PS4_SYSV_ABI sceKernelRaiseException(); +int PS4_SYSV_ABI sceKernelRandomizedPath(); +int PS4_SYSV_ABI sceKernelRdup(); +int PS4_SYSV_ABI sceKernelRead(); +int PS4_SYSV_ABI sceKernelReadTsc(); +int PS4_SYSV_ABI sceKernelReadv(); +int PS4_SYSV_ABI sceKernelReboot(); +int PS4_SYSV_ABI sceKernelReleaseDirectMemory(); +int PS4_SYSV_ABI sceKernelReleaseFlexibleMemory(); +int PS4_SYSV_ABI sceKernelReleaseTraceDirectMemory(); +int PS4_SYSV_ABI sceKernelRemoveExceptionHandler(); +int PS4_SYSV_ABI sceKernelRename(); +int PS4_SYSV_ABI sceKernelReportUnpatchedFunctionCall(); +int PS4_SYSV_ABI sceKernelReserve2mbPage(); +int PS4_SYSV_ABI sceKernelReserveSystemDirectMemory(); +int PS4_SYSV_ABI sceKernelReserveVirtualRange(); +int PS4_SYSV_ABI sceKernelResumeDirectMemoryRelease(); +int PS4_SYSV_ABI sceKernelRmdir(); +int PS4_SYSV_ABI sceKernelRtldControl(); +int PS4_SYSV_ABI sceKernelSandboxPath(); +int PS4_SYSV_ABI sceKernelSendNotificationRequest(); +int PS4_SYSV_ABI sceKernelSetAppInfo(); +int PS4_SYSV_ABI sceKernelSetBackupRestoreMode(); +int PS4_SYSV_ABI sceKernelSetBaseModeClock(); +int PS4_SYSV_ABI sceKernelSetBesteffort(); +int PS4_SYSV_ABI sceKernelSetBootReqNotify(); +int PS4_SYSV_ABI sceKernelSetCallRecord(); +int PS4_SYSV_ABI sceKernelSetCompressionAttribute(); +int PS4_SYSV_ABI sceKernelSetCpumodeGame(); +int PS4_SYSV_ABI sceKernelSetDataTransferMode(); +int PS4_SYSV_ABI sceKernelSetEventFlag(); +int PS4_SYSV_ABI sceKernelSetFsstParam(); +int PS4_SYSV_ABI sceKernelSetGameDirectMemoryLimit(); +int PS4_SYSV_ABI sceKernelSetGPI(); +int PS4_SYSV_ABI sceKernelSetGPO(); +int PS4_SYSV_ABI sceKernelSetGpuCu(); +int PS4_SYSV_ABI sceKernelSetMemoryPstate(); +int PS4_SYSV_ABI sceKernelSetNeoModeClock(); +int PS4_SYSV_ABI sceKernelSetPhysFmemLimit(); +int PS4_SYSV_ABI sceKernelSetProcessName(); +int PS4_SYSV_ABI sceKernelSetProcessProperty(); +int PS4_SYSV_ABI sceKernelSetProcessPropertyString(); +int PS4_SYSV_ABI sceKernelSetPrtAperture(); +int PS4_SYSV_ABI sceKernelSetSafemode(); +int PS4_SYSV_ABI sceKernelSettimeofday(); +int PS4_SYSV_ABI sceKernelSetTimezoneInfo(); +int PS4_SYSV_ABI sceKernelSetVirtualRangeName(); +int PS4_SYSV_ABI sceKernelSetVmContainer(); +int PS4_SYSV_ABI sceKernelSignalSema(); +int PS4_SYSV_ABI sceKernelSleep(); +int PS4_SYSV_ABI sceKernelSlvNotifyError(); +int PS4_SYSV_ABI sceKernelStat(); +int PS4_SYSV_ABI sceKernelStopUnloadModule(); +int PS4_SYSV_ABI sceKernelSuspendDirectMemoryRelease(); +int PS4_SYSV_ABI sceKernelSwitchToBaseMode(); +int PS4_SYSV_ABI sceKernelSwitchToNeoMode(); +int PS4_SYSV_ABI sceKernelSync(); +int PS4_SYSV_ABI sceKernelTerminateSysCore(); +int PS4_SYSV_ABI sceKernelTitleWorkaroundIsEnabled(); +int PS4_SYSV_ABI sceKernelTitleWorkdaroundIsEnabled(); +int PS4_SYSV_ABI sceKernelTraceMemoryTypeProtect(); +int PS4_SYSV_ABI sceKernelTriggerEport(); +int PS4_SYSV_ABI sceKernelTriggerUserEvent(); +int PS4_SYSV_ABI sceKernelTruncate(); +int PS4_SYSV_ABI sceKernelUnlink(); +int PS4_SYSV_ABI sceKernelUsleep(); +int PS4_SYSV_ABI sceKernelUtimes(); +int PS4_SYSV_ABI sceKernelUuidCreate(); +int PS4_SYSV_ABI sceKernelVirtualQuery(); +int PS4_SYSV_ABI sceKernelVirtualQueryAll(); +int PS4_SYSV_ABI sceKernelWaitEqueue(); +int PS4_SYSV_ABI sceKernelWaitEventFlag(); +int PS4_SYSV_ABI sceKernelWaitSema(); +int PS4_SYSV_ABI sceKernelWrite(); +int PS4_SYSV_ABI sceKernelWriteSdkEventLog(); +int PS4_SYSV_ABI sceKernelWritev(); +int PS4_SYSV_ABI sceKernelYieldCpumode(); +int PS4_SYSV_ABI sceLibcMspaceCreateForMonoMutex(); +int PS4_SYSV_ABI scePthreadAtfork(); +int PS4_SYSV_ABI scePthreadAttrDestroy(); +int PS4_SYSV_ABI scePthreadAttrGet(); +int PS4_SYSV_ABI scePthreadAttrGetaffinity(); +int PS4_SYSV_ABI scePthreadAttrGetdetachstate(); +int PS4_SYSV_ABI scePthreadAttrGetguardsize(); +int PS4_SYSV_ABI scePthreadAttrGetinheritsched(); +int PS4_SYSV_ABI scePthreadAttrGetschedparam(); +int PS4_SYSV_ABI scePthreadAttrGetschedpolicy(); +int PS4_SYSV_ABI scePthreadAttrGetscope(); +int PS4_SYSV_ABI scePthreadAttrGetstack(); +int PS4_SYSV_ABI scePthreadAttrGetstackaddr(); +int PS4_SYSV_ABI scePthreadAttrGetstacksize(); +int PS4_SYSV_ABI scePthreadAttrInit(); +int PS4_SYSV_ABI scePthreadAttrSetaffinity(); +int PS4_SYSV_ABI scePthreadAttrSetcreatesuspend(); +int PS4_SYSV_ABI scePthreadAttrSetdetachstate(); +int PS4_SYSV_ABI scePthreadAttrSetguardsize(); +int PS4_SYSV_ABI scePthreadAttrSetinheritsched(); +int PS4_SYSV_ABI scePthreadAttrSetschedparam(); +int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(); +int PS4_SYSV_ABI scePthreadAttrSetscope(); +int PS4_SYSV_ABI scePthreadAttrSetstack(); +int PS4_SYSV_ABI scePthreadAttrSetstackaddr(); +int PS4_SYSV_ABI scePthreadAttrSetstacksize(); +int PS4_SYSV_ABI scePthreadBarrierattrDestroy(); +int PS4_SYSV_ABI scePthreadBarrierattrGetpshared(); +int PS4_SYSV_ABI scePthreadBarrierattrInit(); +int PS4_SYSV_ABI scePthreadBarrierattrSetpshared(); +int PS4_SYSV_ABI scePthreadBarrierDestroy(); +int PS4_SYSV_ABI scePthreadBarrierInit(); +int PS4_SYSV_ABI scePthreadBarrierWait(); +int PS4_SYSV_ABI scePthreadCancel(); +int PS4_SYSV_ABI scePthreadCondattrDestroy(); +int PS4_SYSV_ABI scePthreadCondattrGetclock(); +int PS4_SYSV_ABI scePthreadCondattrGetpshared(); +int PS4_SYSV_ABI scePthreadCondattrInit(); +int PS4_SYSV_ABI scePthreadCondattrSetclock(); +int PS4_SYSV_ABI scePthreadCondattrSetpshared(); +int PS4_SYSV_ABI scePthreadCondBroadcast(); +int PS4_SYSV_ABI scePthreadCondDestroy(); +int PS4_SYSV_ABI scePthreadCondInit(); +int PS4_SYSV_ABI scePthreadCondSignal(); +int PS4_SYSV_ABI scePthreadCondSignalto(); +int PS4_SYSV_ABI scePthreadCondTimedwait(); +int PS4_SYSV_ABI scePthreadCondWait(); +int PS4_SYSV_ABI scePthreadCreate(); +int PS4_SYSV_ABI scePthreadDetach(); +int PS4_SYSV_ABI scePthreadEqual(); +int PS4_SYSV_ABI scePthreadExit(); +int PS4_SYSV_ABI scePthreadGetaffinity(); +int PS4_SYSV_ABI scePthreadGetconcurrency(); +int PS4_SYSV_ABI scePthreadGetcpuclockid(); +int PS4_SYSV_ABI scePthreadGetname(); +int PS4_SYSV_ABI scePthreadGetprio(); +int PS4_SYSV_ABI scePthreadGetschedparam(); +int PS4_SYSV_ABI scePthreadGetspecific(); +int PS4_SYSV_ABI scePthreadGetthreadid(); +int PS4_SYSV_ABI scePthreadJoin(); +int PS4_SYSV_ABI scePthreadKeyCreate(); +int PS4_SYSV_ABI scePthreadKeyDelete(); +int PS4_SYSV_ABI scePthreadMain(); +int PS4_SYSV_ABI scePthreadMulti(); +int PS4_SYSV_ABI scePthreadMutexattrDestroy(); +int PS4_SYSV_ABI scePthreadMutexattrGetkind(); +int PS4_SYSV_ABI scePthreadMutexattrGetprioceiling(); +int PS4_SYSV_ABI scePthreadMutexattrGetprotocol(); +int PS4_SYSV_ABI scePthreadMutexattrGetpshared(); +int PS4_SYSV_ABI scePthreadMutexattrGettype(); +int PS4_SYSV_ABI scePthreadMutexattrInit(); +int PS4_SYSV_ABI scePthreadMutexattrInitForInternalLibc(); +int PS4_SYSV_ABI scePthreadMutexattrSetkind(); +int PS4_SYSV_ABI scePthreadMutexattrSetprioceiling(); +int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(); +int PS4_SYSV_ABI scePthreadMutexattrSetpshared(); +int PS4_SYSV_ABI scePthreadMutexattrSettype(); +int PS4_SYSV_ABI scePthreadMutexDestroy(); +int PS4_SYSV_ABI scePthreadMutexGetprioceiling(); +int PS4_SYSV_ABI scePthreadMutexGetspinloops(); +int PS4_SYSV_ABI scePthreadMutexGetyieldloops(); +int PS4_SYSV_ABI scePthreadMutexInit(); +int PS4_SYSV_ABI scePthreadMutexInitForInternalLibc(); +int PS4_SYSV_ABI scePthreadMutexIsowned(); +int PS4_SYSV_ABI scePthreadMutexLock(); +int PS4_SYSV_ABI scePthreadMutexSetprioceiling(); +int PS4_SYSV_ABI scePthreadMutexSetspinloops(); +int PS4_SYSV_ABI scePthreadMutexSetyieldloops(); +int PS4_SYSV_ABI scePthreadMutexTimedlock(); +int PS4_SYSV_ABI scePthreadMutexTrylock(); +int PS4_SYSV_ABI scePthreadMutexUnlock(); +int PS4_SYSV_ABI scePthreadOnce(); +int PS4_SYSV_ABI scePthreadRename(); +int PS4_SYSV_ABI scePthreadResume(); +int PS4_SYSV_ABI scePthreadResumeAll(); +int PS4_SYSV_ABI scePthreadRwlockattrDestroy(); +int PS4_SYSV_ABI scePthreadRwlockattrGetpshared(); +int PS4_SYSV_ABI scePthreadRwlockattrGettype(); +int PS4_SYSV_ABI scePthreadRwlockattrInit(); +int PS4_SYSV_ABI scePthreadRwlockattrSetpshared(); +int PS4_SYSV_ABI scePthreadRwlockattrSettype(); +int PS4_SYSV_ABI scePthreadRwlockDestroy(); +int PS4_SYSV_ABI scePthreadRwlockInit(); +int PS4_SYSV_ABI scePthreadRwlockRdlock(); +int PS4_SYSV_ABI scePthreadRwlockTimedrdlock(); +int PS4_SYSV_ABI scePthreadRwlockTimedwrlock(); +int PS4_SYSV_ABI scePthreadRwlockTryrdlock(); +int PS4_SYSV_ABI scePthreadRwlockTrywrlock(); +int PS4_SYSV_ABI scePthreadRwlockUnlock(); +int PS4_SYSV_ABI scePthreadRwlockWrlock(); +int PS4_SYSV_ABI scePthreadSelf(); +int PS4_SYSV_ABI scePthreadSemDestroy(); +int PS4_SYSV_ABI scePthreadSemGetvalue(); +int PS4_SYSV_ABI scePthreadSemInit(); +int PS4_SYSV_ABI scePthreadSemPost(); +int PS4_SYSV_ABI scePthreadSemTimedwait(); +int PS4_SYSV_ABI scePthreadSemTrywait(); +int PS4_SYSV_ABI scePthreadSemWait(); +int PS4_SYSV_ABI scePthreadSetaffinity(); +int PS4_SYSV_ABI scePthreadSetBesteffort(); +int PS4_SYSV_ABI scePthreadSetcancelstate(); +int PS4_SYSV_ABI scePthreadSetcanceltype(); +int PS4_SYSV_ABI scePthreadSetconcurrency(); +int PS4_SYSV_ABI scePthreadSetDefaultstacksize(); +int PS4_SYSV_ABI scePthreadSetName(); +int PS4_SYSV_ABI scePthreadSetprio(); +int PS4_SYSV_ABI scePthreadSetschedparam(); +int PS4_SYSV_ABI scePthreadSetspecific(); +int PS4_SYSV_ABI scePthreadSingle(); +int PS4_SYSV_ABI scePthreadSuspend(); +int PS4_SYSV_ABI scePthreadSuspendAll(); +int PS4_SYSV_ABI scePthreadTestcancel(); +int PS4_SYSV_ABI scePthreadTimedjoin(); +int PS4_SYSV_ABI scePthreadYield(); +int PS4_SYSV_ABI sched_get_priority_max(); +int PS4_SYSV_ABI sched_get_priority_min(); +int PS4_SYSV_ABI sched_getparam(); +int PS4_SYSV_ABI sched_getscheduler(); +int PS4_SYSV_ABI sched_rr_get_interval(); +int PS4_SYSV_ABI sched_setparam(); +int PS4_SYSV_ABI sched_setscheduler(); +int PS4_SYSV_ABI sched_yield(); +int PS4_SYSV_ABI select(); +int PS4_SYSV_ABI sem_close(); +int PS4_SYSV_ABI sem_destroy(); +int PS4_SYSV_ABI sem_getvalue(); +int PS4_SYSV_ABI sem_init(); +int PS4_SYSV_ABI sem_open(); +int PS4_SYSV_ABI sem_post(); +int PS4_SYSV_ABI sem_reltimedwait_np(); +int PS4_SYSV_ABI sem_setname(); +int PS4_SYSV_ABI sem_timedwait(); +int PS4_SYSV_ABI sem_trywait(); +int PS4_SYSV_ABI sem_unlink(); +int PS4_SYSV_ABI sem_wait(); +int PS4_SYSV_ABI send(); +int PS4_SYSV_ABI sendfile(); +int PS4_SYSV_ABI sendmsg(); +int PS4_SYSV_ABI sendto(); +int PS4_SYSV_ABI set_phys_fmem_limit(); +int PS4_SYSV_ABI setcontext(); +int PS4_SYSV_ABI setegid(); +int PS4_SYSV_ABI seteuid(); +int PS4_SYSV_ABI setgroups(); +int PS4_SYSV_ABI setitimer(); +int PS4_SYSV_ABI setpriority(); +int PS4_SYSV_ABI setregid(); +int PS4_SYSV_ABI setreuid(); +int PS4_SYSV_ABI setrlimit(); +int PS4_SYSV_ABI setsockopt(); +int PS4_SYSV_ABI settimeofday(); +int PS4_SYSV_ABI setuid(); +int PS4_SYSV_ABI shm_open(); +int PS4_SYSV_ABI shm_unlink(); +int PS4_SYSV_ABI shutdown(); +int PS4_SYSV_ABI sigaction(); +int PS4_SYSV_ABI sigaddset(); +int PS4_SYSV_ABI sigaltstack(); +int PS4_SYSV_ABI sigdelset(); +int PS4_SYSV_ABI sigemptyset(); +int PS4_SYSV_ABI sigfillset(); +int PS4_SYSV_ABI sigismember(); +int PS4_SYSV_ABI siglongjmp(); +int PS4_SYSV_ABI signal(); +int PS4_SYSV_ABI sigpending(); +int PS4_SYSV_ABI sigprocmask(); +int PS4_SYSV_ABI sigqueue(); +int PS4_SYSV_ABI sigreturn(); +int PS4_SYSV_ABI sigsetjmp(); +int PS4_SYSV_ABI sigsuspend(); +int PS4_SYSV_ABI sigtimedwait(); +int PS4_SYSV_ABI sigwait(); +int PS4_SYSV_ABI sigwaitinfo(); +int PS4_SYSV_ABI sleep(); +int PS4_SYSV_ABI socket(); +int PS4_SYSV_ABI socketpair(); +int PS4_SYSV_ABI stat(); +int PS4_SYSV_ABI swapcontext(); +int PS4_SYSV_ABI sync(); +int PS4_SYSV_ABI sysarch(); +int PS4_SYSV_ABI sysconf(); +int PS4_SYSV_ABI sysctl(); +int PS4_SYSV_ABI sysctlbyname(); +int PS4_SYSV_ABI sysctlnametomib(); +int PS4_SYSV_ABI sysKernelGetIntdevModeForRcmgr(); +int PS4_SYSV_ABI sysKernelGetLowerLimitSysexVersion(); +int PS4_SYSV_ABI sysKernelGetLowerLimitUpdVersion(); +int PS4_SYSV_ABI sysKernelGetManufacturingMode(); +int PS4_SYSV_ABI sysKernelGetUpdVersion(); +int PS4_SYSV_ABI system(); +int PS4_SYSV_ABI tcdrain(); +int PS4_SYSV_ABI tcflow(); +int PS4_SYSV_ABI tcflush(); +int PS4_SYSV_ABI tcgetattr(); +int PS4_SYSV_ABI tcgetpgrp(); +int PS4_SYSV_ABI tcgetsid(); +int PS4_SYSV_ABI tcsendbreak(); +int PS4_SYSV_ABI tcsetattr(); +int PS4_SYSV_ABI tcsetpgrp(); +int PS4_SYSV_ABI tcsetsid(); +int PS4_SYSV_ABI truncate(); +int PS4_SYSV_ABI unlink(); +int PS4_SYSV_ABI usleep(); +int PS4_SYSV_ABI utimes(); +int PS4_SYSV_ABI uuidgen(); +int PS4_SYSV_ABI wait(); +int PS4_SYSV_ABI wait3(); +int PS4_SYSV_ABI waitpid(); +int PS4_SYSV_ABI write(); +int PS4_SYSV_ABI writev(); +int PS4_SYSV_ABI Func_37DE1AD13E05E3E5(); +int PS4_SYSV_ABI Func_71A7C3C5AEB8B0EE(); +int PS4_SYSV_ABI Func_829822FC6C04D88B(); +int PS4_SYSV_ABI Func_866AB0F0694DFAD2(); +int PS4_SYSV_ABI Func_8CCB8DA014423D48(); +int PS4_SYSV_ABI Func_AAD1CE2ED156ABB6(); +int PS4_SYSV_ABI Func_B95F988A5707A80B(); +int PS4_SYSV_ABI Func_BDF61AC64C672574(); +int PS4_SYSV_ABI Func_BFEA9394D8C5EA41(); +int PS4_SYSV_ABI Func_C740D02B44D70E4D(); +int PS4_SYSV_ABI Func_D6FDB7C3B4679227(); +int PS4_SYSV_ABI Func_DB02A3203D221953(); +int PS4_SYSV_ABI Func_DB1838257BDA27A9(); +int PS4_SYSV_ABI Func_FCF341DED7E70FC7(); +int PS4_SYSV_ABI Func_FEE3EAF3655B44C2(); +int PS4_SYSV_ABI sceKernelIsProspero(); +int PS4_SYSV_ABI sceKernelGetOpenPsId(); +int PS4_SYSV_ABI Func_0A531D1EEBBE4750(); +int PS4_SYSV_ABI sceKernelGetModuleInfo2(); +int PS4_SYSV_ABI sceKernelGetModuleList2(); +int PS4_SYSV_ABI sceKernelIsModuleLoaded(); +int PS4_SYSV_ABI sysc_e00(); +int PS4_SYSV_ABI sysc_s00(); +int PS4_SYSV_ABI sceCoredumpAttachMemoryRegion(); +int PS4_SYSV_ABI sceCoredumpAttachMemoryRegionAsUserFile(); +int PS4_SYSV_ABI sceCoredumpAttachUserFile(); +int PS4_SYSV_ABI sceCoredumpAttachUserMemoryFile(); +int PS4_SYSV_ABI sceCoredumpConfigDumpMode(); +int PS4_SYSV_ABI sceCoredumpDebugTextOut(); +int PS4_SYSV_ABI sceCoredumpGetStopInfoCpu(); +int PS4_SYSV_ABI sceCoredumpGetStopInfoGpu(); +int PS4_SYSV_ABI sceCoredumpGetThreadContextInfo(); +int PS4_SYSV_ABI sceCoredumpInternalGetThreadContextInfo(); +int PS4_SYSV_ABI sceCoredumpRegisterCoredumpHandler(); +int PS4_SYSV_ABI sceCoredumpSetUserDataType(); +int PS4_SYSV_ABI sceCoredumpUnregisterCoredumpHandler(); +int PS4_SYSV_ABI sceCoredumpWriteUserData(); +int PS4_SYSV_ABI Func_9889095293F9BCAA(); +int PS4_SYSV_ABI sceCoredumpDebugForceCoredumpOnAppClose(); +int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump(); + +void Registerlibkernel(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Kernel \ No newline at end of file From 0525481a9b7272944fa187d18bcb81eb4e3a7b0d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 13:33:38 +0300 Subject: [PATCH 09/14] partial implementation of _write function , which is used as debug ouput from lle libc --- CMakeLists.txt | 2 ++ src/core/hle/libraries/libs.cpp | 4 ++++ src/core/libraries/libkernel.cpp | 16 +++++++++++----- src/core/libraries/libkernel.h | 2 +- src/core/libraries/libsceposix.cpp | 13 +++++++++++++ src/core/libraries/libsceposix.h | 10 ++++++++++ 6 files changed, 41 insertions(+), 6 deletions(-) create mode 100644 src/core/libraries/libsceposix.cpp create mode 100644 src/core/libraries/libsceposix.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 6f8003e0..a64b395e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -112,6 +112,8 @@ set(LIBRARIES src/core/libraries/library_common.h src/core/libraries/libscenet.h src/core/libraries/libscenetctl.cpp src/core/libraries/libscenetctl.h + src/core/libraries/libsceposix.cpp + src/core/libraries/libsceposix.h src/core/libraries/libscesavedata.cpp src/core/libraries/libscesavedata.h src/core/libraries/libscessl.cpp diff --git a/src/core/hle/libraries/libs.cpp b/src/core/hle/libraries/libs.cpp index 6ffc57fb..c379bc36 100644 --- a/src/core/hle/libraries/libs.cpp +++ b/src/core/hle/libraries/libs.cpp @@ -8,12 +8,14 @@ #include "core/hle/libraries/libpad/pad.h" #include "core/hle/libraries/libs.h" #include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h" +#include "src/core/libraries/libkernel.h" #include "src/core/libraries/libsceaudioout.h" #include "src/core/libraries/libscecommondialog.h" #include "src/core/libraries/libscehttp.h" #include "src/core/libraries/libscemsgdialog.h" #include "src/core/libraries/libscenet.h" #include "src/core/libraries/libscenetctl.h" +#include "src/core/libraries/libsceposix.h" #include "src/core/libraries/libscesavedata.h" #include "src/core/libraries/libscessl.h" #include "src/core/libraries/libscesysmodule.h" @@ -43,6 +45,8 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) { Libraries::SaveData::RegisterlibSceSaveData(sym); Libraries::Ssl::RegisterlibSceSsl(sym); Libraries::SysModule::RegisterlibSceSysmodule(sym); + Libraries::Kernel::Registerlibkernel(sym); + Libraries::Posix::Registerlibsceposix(sym); } } // namespace OldLibraries diff --git a/src/core/libraries/libkernel.cpp b/src/core/libraries/libkernel.cpp index 718f784a..c2e68241 100644 --- a/src/core/libraries/libkernel.cpp +++ b/src/core/libraries/libkernel.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later // Generated By moduleGenerator +#include #include "common/logging/log.h" #include "error_codes.h" #include "libkernel.h" @@ -458,8 +459,13 @@ int PS4_SYSV_ABI _wait4() { return ORBIS_OK; } -int PS4_SYSV_ABI _write() { - LOG_ERROR(Kernel, "(STUBBED) called"); +s64 PS4_SYSV_ABI _write(int d, const void* buf, std::size_t nbytes) { + if (d <= 2) { // stdin,stdout,stderr + LOG_INFO(Kernel, "{}", (const char*)buf); + return nbytes; + } + LOG_ERROR(Kernel, "(STUBBED) called d = {} nbytes = {} ", d, nbytes); + UNREACHABLE(); // normal write , is it a posix call?? return ORBIS_OK; } @@ -5253,7 +5259,7 @@ int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump() { return ORBIS_OK; } -void Registerlibkernel(Core::Loader::SymbolsResolver* sym){ +void Registerlibkernel(Core::Loader::SymbolsResolver* sym) { /* LIB_FUNCTION("Fjc4-n1+y2g", "libkernel", 1, "libkernel", 1, 1, __elf_phdr_match_addr); LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __error); LIB_FUNCTION("nSSPVGJLMjE", "libkernel", 1, "libkernel", 1, 1, __freeze); @@ -5348,9 +5354,9 @@ void Registerlibkernel(Core::Loader::SymbolsResolver* sym){ LIB_FUNCTION("6xVpy0Fdq+I", "libkernel", 1, "libkernel", 1, 1, _sigprocmask); LIB_FUNCTION("9zpLsLESzTs", "libkernel", 1, "libkernel", 1, 1, _sigsuspend); LIB_FUNCTION("04AjkP0jO9U", "libkernel", 1, "libkernel", 1, 1, _umtx_op); - LIB_FUNCTION("RFlsu7nfopM", "libkernel", 1, "libkernel", 1, 1, _wait4); + LIB_FUNCTION("RFlsu7nfopM", "libkernel", 1, "libkernel", 1, 1, _wait4);*/ LIB_FUNCTION("FxVZqBAA7ks", "libkernel", 1, "libkernel", 1, 1, _write); - LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev); + /* LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev); LIB_FUNCTION("3e+4Iv7IJ8U", "libkernel", 1, "libkernel", 1, 1, accept); LIB_FUNCTION("8vE6Z6VEYyk", "libkernel", 1, "libkernel", 1, 1, access); LIB_FUNCTION("3SVaehJvYFk", "libkernel", 1, "libkernel", 1, 1, amd64_set_fsbase); diff --git a/src/core/libraries/libkernel.h b/src/core/libraries/libkernel.h index c0cb1fde..0609a108 100644 --- a/src/core/libraries/libkernel.h +++ b/src/core/libraries/libkernel.h @@ -97,7 +97,7 @@ int PS4_SYSV_ABI _sigprocmask(); int PS4_SYSV_ABI _sigsuspend(); int PS4_SYSV_ABI _umtx_op(); int PS4_SYSV_ABI _wait4(); -int PS4_SYSV_ABI _write(); +s64 PS4_SYSV_ABI _write(int d, const void* buf, std::size_t nbytes); int PS4_SYSV_ABI _writev(); int PS4_SYSV_ABI accept(); int PS4_SYSV_ABI access(); diff --git a/src/core/libraries/libsceposix.cpp b/src/core/libraries/libsceposix.cpp new file mode 100644 index 00000000..6d7ce5df --- /dev/null +++ b/src/core/libraries/libsceposix.cpp @@ -0,0 +1,13 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +// Generated By moduleGenerator +#include "common/logging/log.h" +#include "error_codes.h" +#include "libsceposix.h" + +namespace Libraries::Posix { + +void Registerlibsceposix(Core::Loader::SymbolsResolver* sym) {} + +} // namespace Libraries::Posix \ No newline at end of file diff --git a/src/core/libraries/libsceposix.h b/src/core/libraries/libsceposix.h new file mode 100644 index 00000000..4895ebde --- /dev/null +++ b/src/core/libraries/libsceposix.h @@ -0,0 +1,10 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "library_common.h" + +namespace Libraries::Posix { +void Registerlibsceposix(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Posix From 186fa35f1330efd2efba979b1523d95f0fbcba7d Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 17:14:21 +0300 Subject: [PATCH 10/14] added ps4_ prefix to libkernel to make sure it deosn't conflict with linux function names --- src/core/libraries/libkernel.cpp | 11 ++++++----- src/core/libraries/libkernel.h | 10 +++++----- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/src/core/libraries/libkernel.cpp b/src/core/libraries/libkernel.cpp index c2e68241..c689964f 100644 --- a/src/core/libraries/libkernel.cpp +++ b/src/core/libraries/libkernel.cpp @@ -9,6 +9,7 @@ namespace Libraries::Kernel { +/* int PS4_SYSV_ABI __elf_phdr_match_addr() { LOG_ERROR(Kernel, "(STUBBED) called"); return ORBIS_OK; @@ -458,8 +459,8 @@ int PS4_SYSV_ABI _wait4() { LOG_ERROR(Kernel, "(STUBBED) called"); return ORBIS_OK; } - -s64 PS4_SYSV_ABI _write(int d, const void* buf, std::size_t nbytes) { +*/ +s64 PS4_SYSV_ABI ps4__write(int d, const void* buf, std::size_t nbytes) { if (d <= 2) { // stdin,stdout,stderr LOG_INFO(Kernel, "{}", (const char*)buf); return nbytes; @@ -468,7 +469,7 @@ s64 PS4_SYSV_ABI _write(int d, const void* buf, std::size_t nbytes) { UNREACHABLE(); // normal write , is it a posix call?? return ORBIS_OK; } - +/* int PS4_SYSV_ABI _writev() { LOG_ERROR(Kernel, "(STUBBED) called"); return ORBIS_OK; @@ -5258,7 +5259,7 @@ int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump() { LOG_ERROR(Kernel, "(STUBBED) called"); return ORBIS_OK; } - +*/ void Registerlibkernel(Core::Loader::SymbolsResolver* sym) { /* LIB_FUNCTION("Fjc4-n1+y2g", "libkernel", 1, "libkernel", 1, 1, __elf_phdr_match_addr); LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __error); @@ -5355,7 +5356,7 @@ void Registerlibkernel(Core::Loader::SymbolsResolver* sym) { LIB_FUNCTION("9zpLsLESzTs", "libkernel", 1, "libkernel", 1, 1, _sigsuspend); LIB_FUNCTION("04AjkP0jO9U", "libkernel", 1, "libkernel", 1, 1, _umtx_op); LIB_FUNCTION("RFlsu7nfopM", "libkernel", 1, "libkernel", 1, 1, _wait4);*/ - LIB_FUNCTION("FxVZqBAA7ks", "libkernel", 1, "libkernel", 1, 1, _write); + LIB_FUNCTION("FxVZqBAA7ks", "libkernel", 1, "libkernel", 1, 1, ps4__write); /* LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev); LIB_FUNCTION("3e+4Iv7IJ8U", "libkernel", 1, "libkernel", 1, 1, accept); LIB_FUNCTION("8vE6Z6VEYyk", "libkernel", 1, "libkernel", 1, 1, access); diff --git a/src/core/libraries/libkernel.h b/src/core/libraries/libkernel.h index 0609a108..72b6a804 100644 --- a/src/core/libraries/libkernel.h +++ b/src/core/libraries/libkernel.h @@ -6,7 +6,7 @@ #include "library_common.h" namespace Libraries::Kernel { - +/* int PS4_SYSV_ABI __elf_phdr_match_addr(); int PS4_SYSV_ABI __error(); int PS4_SYSV_ABI __freeze(); @@ -96,9 +96,9 @@ int PS4_SYSV_ABI _sigintr(); int PS4_SYSV_ABI _sigprocmask(); int PS4_SYSV_ABI _sigsuspend(); int PS4_SYSV_ABI _umtx_op(); -int PS4_SYSV_ABI _wait4(); -s64 PS4_SYSV_ABI _write(int d, const void* buf, std::size_t nbytes); -int PS4_SYSV_ABI _writev(); +int PS4_SYSV_ABI _wait4();*/ +s64 PS4_SYSV_ABI ps4__write(int d, const void* buf, std::size_t nbytes); +/* int PS4_SYSV_ABI _writev(); int PS4_SYSV_ABI accept(); int PS4_SYSV_ABI access(); int PS4_SYSV_ABI amd64_set_fsbase(); @@ -1055,7 +1055,7 @@ int PS4_SYSV_ABI sceCoredumpUnregisterCoredumpHandler(); int PS4_SYSV_ABI sceCoredumpWriteUserData(); int PS4_SYSV_ABI Func_9889095293F9BCAA(); int PS4_SYSV_ABI sceCoredumpDebugForceCoredumpOnAppClose(); -int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump(); +int PS4_SYSV_ABI sceCoredumpDebugTriggerCoredump();*/ void Registerlibkernel(Core::Loader::SymbolsResolver* sym); } // namespace Libraries::Kernel \ No newline at end of file From a21722a1db1b0b21b99f7ee07fb853e12951d6b4 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 17:37:09 +0300 Subject: [PATCH 11/14] fixed linux issue with enums --- src/core/libraries/libscesysmodule.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/core/libraries/libscesysmodule.cpp b/src/core/libraries/libscesysmodule.cpp index d47ff136..43ff4416 100644 --- a/src/core/libraries/libscesysmodule.cpp +++ b/src/core/libraries/libscesysmodule.cpp @@ -2,6 +2,8 @@ // SPDX-License-Identifier: GPL-2.0-or-later // Generated By moduleGenerator +#define MAGIC_ENUM_RANGE_MIN 0 +#define MAGIC_ENUM_RANGE_MAX 300 #include #include "common/logging/log.h" #include "error_codes.h" @@ -39,12 +41,6 @@ int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal() { return ORBIS_OK; } -template <> -struct magic_enum::customize::enum_range { - static constexpr int min = 0; - static constexpr int max = 300; -}; - int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id) { auto color_name = magic_enum::enum_name(id); LOG_ERROR(Lib_SysModule, "(DUMMY) called module = {}", magic_enum::enum_name(id)); From 03b3194c44f06e6c2e5cbd02d5699f37c9db4ccc Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 18:04:11 +0300 Subject: [PATCH 12/14] fixed (?) _write function --- src/core/libraries/libkernel.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/core/libraries/libkernel.cpp b/src/core/libraries/libkernel.cpp index c689964f..94b41a8e 100644 --- a/src/core/libraries/libkernel.cpp +++ b/src/core/libraries/libkernel.cpp @@ -3,6 +3,7 @@ // Generated By moduleGenerator #include +#include #include "common/logging/log.h" #include "error_codes.h" #include "libkernel.h" @@ -462,7 +463,11 @@ int PS4_SYSV_ABI _wait4() { */ s64 PS4_SYSV_ABI ps4__write(int d, const void* buf, std::size_t nbytes) { if (d <= 2) { // stdin,stdout,stderr - LOG_INFO(Kernel, "{}", (const char*)buf); + char* str = strdup((const char*)buf); + if (str[nbytes - 1] == '\n') + str[nbytes - 1] = 0; + LOG_INFO(Kernel, "{}", str); + free(str); return nbytes; } LOG_ERROR(Kernel, "(STUBBED) called d = {} nbytes = {} ", d, nbytes); From 2382e7789812cdcb4177db4038a54304211c1f14 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Sun, 31 Mar 2024 18:04:47 +0300 Subject: [PATCH 13/14] sceKernelClose,sceKernelRead,sceKernelLseek implementation --- .../hle/libraries/libkernel/file_system.cpp | 43 ++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/src/core/hle/libraries/libkernel/file_system.cpp b/src/core/hle/libraries/libkernel/file_system.cpp index 0046b9d5..32aba023 100644 --- a/src/core/hle/libraries/libkernel/file_system.cpp +++ b/src/core/hle/libraries/libkernel/file_system.cpp @@ -13,6 +13,8 @@ namespace Core::Libraries::LibKernel { int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) { LOG_INFO(Kernel_Fs, "path = {} flags = {:#x} mode = {:#x}", path, flags, mode); + ASSERT_MSG(flags == 0, "flags!=0 not supported yet"); + ASSERT_MSG(mode == 0, "mode!=0 not supported yet"); auto* h = Common::Singleton::Instance(); auto* mnt = Common::Singleton::Instance(); @@ -39,6 +41,21 @@ int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16 return result; } +int PS4_SYSV_ABI sceKernelClose(int d) { + auto* h = Common::Singleton::Instance(); + auto* file = h->GetFile(d); + if (file == nullptr) { + return SCE_KERNEL_ERROR_EBADF; + } + if (!file->is_directory) { + file->f.Close(); + } + file->is_opened = false; + LOG_INFO(Kernel_Fs, "Closing {}", file->m_guest_name); + h->DeleteHandle(d); + return SCE_OK; +} + size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) { auto* h = Common::Singleton::Instance(); auto* file = h->GetFile(d); @@ -51,7 +68,7 @@ size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) { return total_read; } -s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) { +s64 PS4_SYSV_ABI sceKernelLseek(int d, s64 offset, int whence) { auto* h = Common::Singleton::Instance(); auto* file = h->GetFile(d); @@ -74,11 +91,35 @@ s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) { return pos; } +s64 PS4_SYSV_ABI lseek(int d, s64 offset, int whence) { + return sceKernelLseek(d, offset, whence); +} + +s64 PS4_SYSV_ABI sceKernelRead(int d, void* buf, size_t nbytes) { + if (buf == nullptr) { + return SCE_KERNEL_ERROR_EFAULT; + } + + auto* h = Common::Singleton::Instance(); + auto* file = h->GetFile(d); + if (file == nullptr) { + return SCE_KERNEL_ERROR_EBADF; + } + file->m_mutex.lock(); + u32 bytes_read = file->f.ReadRaw(buf, static_cast(nbytes)); + file->m_mutex.unlock(); + return bytes_read; +} + void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) { LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen); LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open); + LIB_FUNCTION("UK2Tl2DWUns", "libkernel", 1, "libkernel", 1, 1, sceKernelClose); + LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv); LIB_FUNCTION("Oy6IpwgtYOk", "libkernel", 1, "libkernel", 1, 1, lseek); + LIB_FUNCTION("oib76F-12fk", "libkernel", 1, "libkernel", 1, 1, sceKernelLseek); + LIB_FUNCTION("Cg4srZ6TKbU", "libkernel", 1, "libkernel", 1, 1, sceKernelRead); // openOrbis (to check if it is valid out of OpenOrbis LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1, From 06d6ad09eadcd9e6faa9db3e376a541ac3d28025 Mon Sep 17 00:00:00 2001 From: georgemoralis Date: Mon, 1 Apr 2024 08:44:07 +0300 Subject: [PATCH 14/14] log debug message to tty --- src/common/logging/filter.cpp | 1 + src/common/logging/types.h | 1 + src/core/libraries/libkernel.cpp | 2 +- 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp index 0714362c..ac38ab0f 100644 --- a/src/common/logging/filter.cpp +++ b/src/common/logging/filter.cpp @@ -98,6 +98,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) { CLS(Render) \ SUB(Render, Vulkan) \ CLS(Input) \ + CLS(Tty) \ CLS(Loader) // GetClassName is a macro defined by Windows.h, grrr... diff --git a/src/common/logging/types.h b/src/common/logging/types.h index 1d848d74..897929be 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -66,6 +66,7 @@ enum class Class : u8 { Render_Vulkan, ///< Vulkan backend Loader, ///< ROM loader Input, ///< Input emulation + Tty, ///< Debug output from emu Count ///< Total number of logging classes }; diff --git a/src/core/libraries/libkernel.cpp b/src/core/libraries/libkernel.cpp index 94b41a8e..5ce0bd00 100644 --- a/src/core/libraries/libkernel.cpp +++ b/src/core/libraries/libkernel.cpp @@ -466,7 +466,7 @@ s64 PS4_SYSV_ABI ps4__write(int d, const void* buf, std::size_t nbytes) { char* str = strdup((const char*)buf); if (str[nbytes - 1] == '\n') str[nbytes - 1] = 0; - LOG_INFO(Kernel, "{}", str); + LOG_INFO(Tty, "{}", str); free(str); return nbytes; }