mirror of
https://github.com/DarkMatterCore/nxdumptool.git
synced 2024-11-23 10:42:09 +00:00
0ec60092df
Speeds up title lookups using a specific storage ID. Also reworked a bit the way orphan titles are handled. Should be better now.
2133 lines
77 KiB
C
2133 lines
77 KiB
C
/*
|
|
* title.c
|
|
*
|
|
* Copyright (c) 2020-2021, DarkMatterCore <pabloacurielz@gmail.com>.
|
|
*
|
|
* This file is part of nxdumptool (https://github.com/DarkMatterCore/nxdumptool).
|
|
*
|
|
* nxdumptool is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* nxdumptool is distributed in the hope it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "utils.h"
|
|
#include "title.h"
|
|
#include "gamecard.h"
|
|
|
|
#define NS_APPLICATION_RECORD_LIMIT 4096
|
|
|
|
/* Type definitions. */
|
|
|
|
typedef struct {
|
|
u64 title_id;
|
|
char name[32];
|
|
} SystemTitleName;
|
|
|
|
/* Global variables. */
|
|
|
|
static Mutex g_titleMutex = 0;
|
|
static Thread g_titleGameCardInfoThread = {0};
|
|
static UEvent g_titleGameCardInfoThreadExitEvent = {0}, *g_titleGameCardStatusChangeUserEvent = NULL, g_titleGameCardUpdateInfoUserEvent = {0};
|
|
static CondVar g_gameCardCondVar = 0;
|
|
|
|
static bool g_titleInterfaceInit = false, g_titleGameCardInfoThreadCreated = false, g_titleGameCardAvailable = false, g_titleGameCardInfoUpdated = false;
|
|
|
|
static NsApplicationControlData *g_nsAppControlData = NULL;
|
|
|
|
static TitleApplicationMetadata **g_appMetadata = NULL;
|
|
static u32 g_appMetadataCount = 0;
|
|
|
|
static NcmContentMetaDatabase g_ncmDbGameCard = {0}, g_ncmDbEmmcSystem = {0}, g_ncmDbEmmcUser = {0}, g_ncmDbSdCard = {0};
|
|
static NcmContentStorage g_ncmStorageGameCard = {0}, g_ncmStorageEmmcSystem = {0}, g_ncmStorageEmmcUser = {0}, g_ncmStorageSdCard = {0};
|
|
|
|
static TitleInfo **g_titleInfo = NULL;
|
|
static u32 g_titleInfoCount = 0;
|
|
|
|
static u32 g_titleInfoBuiltInSystemCount = 0; /* Start index is always zero. */
|
|
static u32 g_titleInfoBuiltInUserStartIndex = 0, g_titleInfoBuiltInUserCount = 0;
|
|
static u32 g_titleInfoSdCardStartIndex = 0, g_titleInfoSdCardCount = 0;
|
|
static u32 g_titleInfoGameCardStartIndex = 0, g_titleInfoGameCardCount = 0;
|
|
|
|
static TitleInfo **g_orphanTitleInfo = NULL;
|
|
static u32 g_orphanTitleInfoCount = 0;
|
|
|
|
static const char *g_titleNcmContentTypeNames[] = {
|
|
[NcmContentType_Meta] = "Meta",
|
|
[NcmContentType_Program] = "Program",
|
|
[NcmContentType_Data] = "Data",
|
|
[NcmContentType_Control] = "Control",
|
|
[NcmContentType_HtmlDocument] = "HtmlDocument",
|
|
[NcmContentType_LegalInformation] = "LegalInformation",
|
|
[NcmContentType_DeltaFragment] = "DeltaFragment"
|
|
};
|
|
|
|
static const char *g_titleNcmContentMetaTypeNames[] = {
|
|
[NcmContentMetaType_Unknown] = "Unknown",
|
|
[NcmContentMetaType_SystemProgram] = "SystemProgram",
|
|
[NcmContentMetaType_SystemData] = "SystemData",
|
|
[NcmContentMetaType_SystemUpdate] = "SystemUpdate",
|
|
[NcmContentMetaType_BootImagePackage] = "BootImagePackage",
|
|
[NcmContentMetaType_BootImagePackageSafe] = "BootImagePackageSafe",
|
|
[NcmContentMetaType_Application - 0x7A] = "Application",
|
|
[NcmContentMetaType_Patch - 0x7A] = "Patch",
|
|
[NcmContentMetaType_AddOnContent - 0x7A] = "AddOnContent",
|
|
[NcmContentMetaType_Delta - 0x7A] = "Delta"
|
|
};
|
|
|
|
static const char *g_filenameTypeStrings[] = {
|
|
[NcmContentMetaType_Application - 0x80] = "BASE",
|
|
[NcmContentMetaType_Patch - 0x80] = "UPD",
|
|
[NcmContentMetaType_AddOnContent - 0x80] = "DLC",
|
|
[NcmContentMetaType_Delta - 0x80] = "DELTA"
|
|
};
|
|
|
|
/* Info retrieved from https://switchbrew.org/wiki/Title_list. */
|
|
/* Titles bundled with the kernel are excluded. */
|
|
static const SystemTitleName g_systemTitles[] = {
|
|
/* System modules. */
|
|
/* Meta + Program NCAs. */
|
|
{ 0x0100000000000006, "usb" },
|
|
{ 0x0100000000000007, "tma" },
|
|
{ 0x0100000000000008, "boot2" },
|
|
{ 0x0100000000000009, "settings" },
|
|
{ 0x010000000000000A, "bus" },
|
|
{ 0x010000000000000B, "bluetooth" },
|
|
{ 0x010000000000000C, "bcat" },
|
|
{ 0x010000000000000D, "dmnt" },
|
|
{ 0x010000000000000E, "friends" },
|
|
{ 0x010000000000000F, "nifm" },
|
|
{ 0x0100000000000010, "ptm" },
|
|
{ 0x0100000000000011, "shell" },
|
|
{ 0x0100000000000012, "bsdsockets" },
|
|
{ 0x0100000000000013, "hid" },
|
|
{ 0x0100000000000014, "audio" },
|
|
{ 0x0100000000000015, "LogManager" },
|
|
{ 0x0100000000000016, "wlan" },
|
|
{ 0x0100000000000017, "cs" },
|
|
{ 0x0100000000000018, "ldn" },
|
|
{ 0x0100000000000019, "nvservices" },
|
|
{ 0x010000000000001A, "pcv" },
|
|
{ 0x010000000000001B, "capmtp" },
|
|
{ 0x010000000000001C, "nvnflinger" },
|
|
{ 0x010000000000001D, "pcie" },
|
|
{ 0x010000000000001E, "account" },
|
|
{ 0x010000000000001F, "ns" },
|
|
{ 0x0100000000000020, "nfc" },
|
|
{ 0x0100000000000021, "psc" },
|
|
{ 0x0100000000000022, "capsrv" },
|
|
{ 0x0100000000000023, "am" },
|
|
{ 0x0100000000000024, "ssl" },
|
|
{ 0x0100000000000025, "nim" },
|
|
{ 0x0100000000000026, "cec" },
|
|
{ 0x0100000000000027, "tspm" },
|
|
{ 0x0100000000000029, "lbl" },
|
|
{ 0x010000000000002A, "btm" },
|
|
{ 0x010000000000002B, "erpt" },
|
|
{ 0x010000000000002C, "time" },
|
|
{ 0x010000000000002D, "vi" },
|
|
{ 0x010000000000002E, "pctl" },
|
|
{ 0x010000000000002F, "npns" },
|
|
{ 0x0100000000000030, "eupld" },
|
|
{ 0x0100000000000031, "glue" },
|
|
{ 0x0100000000000032, "eclct" },
|
|
{ 0x0100000000000033, "es" },
|
|
{ 0x0100000000000034, "fatal" },
|
|
{ 0x0100000000000035, "grc" },
|
|
{ 0x0100000000000036, "creport" },
|
|
{ 0x0100000000000037, "ro" },
|
|
{ 0x0100000000000038, "profiler" },
|
|
{ 0x0100000000000039, "sdb" },
|
|
{ 0x010000000000003A, "migration" },
|
|
{ 0x010000000000003B, "jit" },
|
|
{ 0x010000000000003C, "jpegdec" },
|
|
{ 0x010000000000003D, "safemode" },
|
|
{ 0x010000000000003E, "olsc" },
|
|
{ 0x010000000000003F, "dt" },
|
|
{ 0x0100000000000040, "nd" },
|
|
{ 0x0100000000000041, "ngct" },
|
|
{ 0x0100000000000042, "pgl" },
|
|
|
|
/* System data archives. */
|
|
/* Meta + Data NCAs. */
|
|
{ 0x0100000000000800, "CertStore" },
|
|
{ 0x0100000000000801, "ErrorMessage" },
|
|
{ 0x0100000000000802, "MiiModel" },
|
|
{ 0x0100000000000803, "BrowserDll" },
|
|
{ 0x0100000000000804, "Help" },
|
|
{ 0x0100000000000805, "SharedFont" },
|
|
{ 0x0100000000000806, "NgWord" },
|
|
{ 0x0100000000000807, "SsidList" },
|
|
{ 0x0100000000000808, "Dictionary" },
|
|
{ 0x0100000000000809, "SystemVersion" },
|
|
{ 0x010000000000080A, "AvatarImage" },
|
|
{ 0x010000000000080B, "LocalNews" },
|
|
{ 0x010000000000080C, "Eula" },
|
|
{ 0x010000000000080D, "UrlBlackList" },
|
|
{ 0x010000000000080E, "TimeZoneBinary" },
|
|
{ 0x010000000000080F, "CertStoreCruiser" },
|
|
{ 0x0100000000000810, "FontNintendoExtension" },
|
|
{ 0x0100000000000811, "FontStandard" },
|
|
{ 0x0100000000000812, "FontKorean" },
|
|
{ 0x0100000000000813, "FontChineseTraditional" },
|
|
{ 0x0100000000000814, "FontChineseSimple" },
|
|
{ 0x0100000000000815, "FontBfcpx" },
|
|
{ 0x0100000000000816, "SystemUpdate" },
|
|
{ 0x0100000000000818, "FirmwareDebugSettings" },
|
|
{ 0x0100000000000819, "BootImagePackage" },
|
|
{ 0x010000000000081A, "BootImagePackageSafe" },
|
|
{ 0x010000000000081B, "BootImagePackageExFat" },
|
|
{ 0x010000000000081C, "BootImagePackageExFatSafe" },
|
|
{ 0x010000000000081D, "FatalMessage" },
|
|
{ 0x010000000000081E, "ControllerIcon" },
|
|
{ 0x010000000000081F, "PlatformConfigIcosa" },
|
|
{ 0x0100000000000820, "PlatformConfigCopper" },
|
|
{ 0x0100000000000821, "PlatformConfigHoag" },
|
|
{ 0x0100000000000822, "ControllerFirmware" },
|
|
{ 0x0100000000000823, "NgWord2" },
|
|
{ 0x0100000000000824, "PlatformConfigIcosaMariko" },
|
|
{ 0x0100000000000825, "ApplicationBlackList" },
|
|
{ 0x0100000000000826, "RebootlessSystemUpdateVersion" },
|
|
{ 0x0100000000000827, "ContentActionTable" },
|
|
{ 0x0100000000000828, "FunctionBlackList" },
|
|
{ 0x0100000000000830, "NgWordT" },
|
|
|
|
/* System applets. */
|
|
/* Meta + Program NCAs. */
|
|
{ 0x0100000000001000, "qlaunch" },
|
|
{ 0x0100000000001001, "auth" },
|
|
{ 0x0100000000001002, "cabinet" },
|
|
{ 0x0100000000001003, "controller" },
|
|
{ 0x0100000000001004, "dataErase" },
|
|
{ 0x0100000000001005, "error" },
|
|
{ 0x0100000000001006, "netConnect" },
|
|
{ 0x0100000000001007, "playerSelect" },
|
|
{ 0x0100000000001008, "swkbd" },
|
|
{ 0x0100000000001009, "miiEdit" },
|
|
{ 0x010000000000100A, "web" },
|
|
{ 0x010000000000100B, "shop" },
|
|
{ 0x010000000000100C, "overlayDisp" },
|
|
{ 0x010000000000100D, "photoViewer" },
|
|
{ 0x010000000000100E, "set" },
|
|
{ 0x010000000000100F, "offlineWeb" },
|
|
{ 0x0100000000001010, "loginShare" },
|
|
{ 0x0100000000001011, "wifiWebAuth" },
|
|
{ 0x0100000000001012, "starter" },
|
|
{ 0x0100000000001013, "myPage" },
|
|
{ 0x0100000000001014, "PlayReport" },
|
|
{ 0x0100000000001015, "MaintenanceMenu" },
|
|
{ 0x010000000000101A, "gift" },
|
|
{ 0x010000000000101B, "DummyECApplet" },
|
|
{ 0x010000000000101C, "userMigration" },
|
|
{ 0x010000000000101D, "EncounterSys" },
|
|
{ 0x0100000000001020, "story" },
|
|
{ 0x0100000000001023, "statistics" },
|
|
{ 0x0100000000001033, "promotion" },
|
|
{ 0x0100000000001038, "sample" },
|
|
{ 0x0100000000001FFF, "EndOceanProgramId" },
|
|
|
|
/* System debug applets. */
|
|
{ 0x0100000000002000, "A2BoardFunction" },
|
|
{ 0x0100000000002001, "A3Wireless" },
|
|
{ 0x0100000000002002, "C1LcdAndKey" },
|
|
{ 0x0100000000002003, "C2UsbHpmic" },
|
|
{ 0x0100000000002004, "C3Aging" },
|
|
{ 0x0100000000002005, "C4SixAxis" },
|
|
{ 0x0100000000002006, "C5Wireless" },
|
|
{ 0x0100000000002007, "C7FinalCheck" },
|
|
{ 0x010000000000203F, "AutoCapture" },
|
|
{ 0x0100000000002040, "DevMenuCommandSystem" },
|
|
{ 0x0100000000002041, "recovery" },
|
|
{ 0x0100000000002042, "DevMenuSystem" },
|
|
{ 0x0100000000002044, "HB-TBIntegrationTest" },
|
|
{ 0x010000000000204D, "BackupSaveData" },
|
|
{ 0x010000000000204E, "A4BoardCalWriti" },
|
|
{ 0x0100000000002054, "RepairSslCertificate" },
|
|
{ 0x0100000000002055, "GameCardWriter" },
|
|
{ 0x0100000000002056, "UsbPdTestTool" },
|
|
{ 0x0100000000002057, "RepairDeletePctl" },
|
|
{ 0x0100000000002058, "RepairBackup" },
|
|
{ 0x0100000000002059, "RepairRestore" },
|
|
{ 0x010000000000205A, "RepairAccountTransfer" },
|
|
{ 0x010000000000205B, "RepairAutoNetworkUpdater" },
|
|
{ 0x010000000000205C, "RefurbishReset" },
|
|
{ 0x010000000000205D, "RepairAssistCup" },
|
|
{ 0x010000000000205E, "RepairPairingCutter" },
|
|
{ 0x0100000000002064, "DevMenu" },
|
|
{ 0x0100000000002065, "DevMenuApp" },
|
|
{ 0x0100000000002066, "GetGameCardAsicInfo" },
|
|
{ 0x0100000000002068, "NfpDebugToolSystem" },
|
|
{ 0x0100000000002069, "AlbumSynchronizer" },
|
|
{ 0x0100000000002071, "SnapShotDumper" },
|
|
{ 0x0100000000002073, "DevMenuSystemApp" },
|
|
{ 0x0100000000002099, "DevOverlayDisp" },
|
|
{ 0x010000000000209A, "NandVerifier" },
|
|
{ 0x010000000000209B, "GpuCoreDumper" },
|
|
{ 0x010000000000209C, "TestApplication" },
|
|
{ 0x010000000000209E, "HelloWorld" },
|
|
{ 0x01000000000020A0, "XcieWriter" },
|
|
{ 0x01000000000020A1, "GpuOverrunNotifier" },
|
|
{ 0x01000000000020C8, "NfpDebugTool" },
|
|
{ 0x01000000000020CA, "NoftWriter" },
|
|
{ 0x01000000000020D0, "BcatSystemDebugTool" },
|
|
{ 0x01000000000020D1, "DevSafeModeUpdater" },
|
|
{ 0x01000000000020D3, "ControllerConnectionAnalyzer" },
|
|
{ 0x01000000000020D4, "DevKitUpdater" },
|
|
{ 0x01000000000020D6, "RepairTimeReviser" },
|
|
{ 0x01000000000020D7, "RepairReinitializeFuelGauge" },
|
|
{ 0x01000000000020DA, "RepairAbortMigration" },
|
|
{ 0x01000000000020DC, "RepairShowDeviceId" },
|
|
{ 0x01000000000020DD, "RepairSetCycleCountReliability" },
|
|
{ 0x01000000000020E0, "Interface" },
|
|
{ 0x01000000000020E1, "AlbumDownloader" },
|
|
{ 0x01000000000020E3, "FuelGaugeDumper" },
|
|
{ 0x01000000000020E4, "UnsafeExtract" },
|
|
{ 0x01000000000020E5, "UnsafeEngrave" },
|
|
{ 0x01000000000020EE, "BluetoothSettingTool" },
|
|
{ 0x01000000000020F0, "ApplicationInstallerRomfs" },
|
|
{ 0x0100000000002100, "DevMenuLotcheckDownloader" },
|
|
{ 0x0100000000002101, "DevMenuCommand" },
|
|
{ 0x0100000000002102, "ExportPartition" },
|
|
{ 0x0100000000002103, "SystemInitializer" },
|
|
{ 0x0100000000002104, "SystemUpdaterHostFs" },
|
|
{ 0x0100000000002105, "WriteToStorage" },
|
|
{ 0x0100000000002106, "CalWriter" },
|
|
{ 0x0100000000002107, "SettingsManager" },
|
|
{ 0x0100000000002109, "testBuildSystemIris" },
|
|
{ 0x010000000000210A, "SystemUpdater" },
|
|
{ 0x010000000000210B, "nvnflinger_util" },
|
|
{ 0x010000000000210C, "ControllerFirmwareUpdater" },
|
|
{ 0x010000000000210D, "testBuildSystemNintendoWare" },
|
|
{ 0x0100000000002110, "TestSaveDataCreator" },
|
|
{ 0x0100000000002111, "C9LcdSpker" },
|
|
{ 0x0100000000002114, "RankTurn" },
|
|
{ 0x0100000000002116, "BleTestTool" },
|
|
{ 0x010000000000211A, "PreinstallAppWriter" },
|
|
{ 0x010000000000211C, "ControllerSerialFlashTool" },
|
|
{ 0x010000000000211D, "ControllerFlashWriter" },
|
|
{ 0x0100000000002120, "ControllerTestApp" },
|
|
{ 0x0100000000002121, "HidInspectionTool" },
|
|
{ 0x0100000000002124, "BatteryCyclesEditor" },
|
|
{ 0x0100000000002125, "UsbFirmwareUpdater" },
|
|
{ 0x0100000000002126, "PalmaSerialCodeTool" },
|
|
{ 0x0100000000002127, "renderdoccmd" },
|
|
{ 0x0100000000002128, "HidInspectionToolProd" },
|
|
{ 0x010000000000212C, "ExhibitionMenu" },
|
|
{ 0x010000000000212F, "ExhibitionSaveData" },
|
|
{ 0x0100000000002130, "LuciaConverter" },
|
|
{ 0x0100000000002133, "CalDumper" },
|
|
{ 0x0100000000002134, "AnalogStickEvaluationTool" },
|
|
|
|
/* System debug modules. */
|
|
{ 0x0100000000003002, "DummyProcess" },
|
|
{ 0x0100000000003003, "DebugMonitor0" },
|
|
{ 0x0100000000003004, "SystemHelloWorld" },
|
|
|
|
/* Target tools. */
|
|
{ 0x1000000000000001, "SystemInitializer" },
|
|
{ 0x1000000000000004, "CalWriter" },
|
|
{ 0x1000000000000005, "DevMenuCommand" },
|
|
{ 0x1000000000000006, "SettingsManager" },
|
|
{ 0x1000000000000007, "ApplicationLauncer" },
|
|
{ 0x100000000000000B, "SnapShotDumper" },
|
|
{ 0x100000000000000C, "SystemUpdater" },
|
|
{ 0x100000000000000E, "ControllerFirmwareUpdater" },
|
|
|
|
/* Factory system modules. */
|
|
{ 0x010000000000B120, "nvdbgsvc" },
|
|
{ 0x010000000000B14A, "manu" },
|
|
{ 0x010000000000B14B, "ManuUsbLoopBack" },
|
|
{ 0x010000000000B1B8, "DevFwdbgHbPackage" },
|
|
{ 0x010000000000B1B9, "DevFwdbgUsbPackage" },
|
|
{ 0x010000000000B1BA, "ProdFwdbgPackage" },
|
|
{ 0x010000000000B22A, "scs" },
|
|
{ 0x010000000000B22B, "ControllerFirmwareDebug" },
|
|
{ 0x010000000000B240, "htc.stub" },
|
|
{ 0x010000000000C600, "BdkSample01" },
|
|
{ 0x010000000000C601, "BdkSample02" },
|
|
{ 0x010000000000C602, "BdkSample03" },
|
|
{ 0x010000000000C603, "BdkSample04" },
|
|
{ 0x010000000000D609, "dmnt.gen2" },
|
|
{ 0x010000000000D623, "DevServer" },
|
|
|
|
/* System applications. */
|
|
{ 0x01008BB00013C000, "flog" },
|
|
{ 0x0100069000078000, "RetailInteractiveDisplayMenu" },
|
|
{ 0x010000B003486000, "AudioUsbMicDebugTool" },
|
|
{ 0x0100458001E04000, "BcatTestApp01" },
|
|
{ 0x0100F910020F8000, "BcatTestApp02" },
|
|
{ 0x0100B7D0020FC000, "BcatTestApp03" },
|
|
{ 0x0100132002100000, "BcatTestApp04" },
|
|
{ 0x0100935002116000, "BcatTestApp05" },
|
|
{ 0x0100DA4002130000, "BcatTestApp06" },
|
|
{ 0x0100B0F002104000, "BcatTestApp07" },
|
|
{ 0x010051E002132000, "BcatTestApp08" },
|
|
{ 0x01004CB0015C8000, "BcatTestApp09" },
|
|
{ 0x01009720015CA000, "BcatTestApp10" },
|
|
{ 0x01002F20015C6000, "BcatTestApp11" },
|
|
{ 0x0100204001F90000, "BcatTestApp12" },
|
|
{ 0x0100060001F92000, "BcatTestApp13" },
|
|
{ 0x0100C26001F94000, "BcatTestApp14" },
|
|
{ 0x0100462001F96000, "BcatTestApp15" },
|
|
{ 0x01005C6001F98000, "BcatTestApp16" },
|
|
{ 0x010070000E3C0000, "EncounterUsr" },
|
|
{ 0x010086000E49C000, "EncounterUsrDummy" },
|
|
{ 0x0100810002D5A000, "ShopMonitaringTool" },
|
|
{ 0x010023D002B98000, "DeltaStress" }
|
|
};
|
|
|
|
static const u32 g_systemTitlesCount = MAX_ELEMENTS(g_systemTitles);
|
|
|
|
/* Function prototypes. */
|
|
|
|
NX_INLINE void titleFreeApplicationMetadata(void);
|
|
static bool titleReallocateApplicationMetadata(u32 extra_app_count, bool free_entries);
|
|
|
|
NX_INLINE void titleFreeTitleInfo(void);
|
|
static bool titleReallocateTitleInfo(u32 extra_title_count, bool free_entries);
|
|
|
|
NX_INLINE void titleFreeOrphanTitleInfo(void);
|
|
static void titleAddOrphanTitleInfoEntry(TitleInfo *orphan_title);
|
|
|
|
NX_INLINE TitleApplicationMetadata *titleFindApplicationMetadataByTitleId(u64 title_id);
|
|
|
|
static bool titleGenerateMetadataEntriesFromSystemTitles(void);
|
|
static bool titleGenerateMetadataEntriesFromNsRecords(void);
|
|
static bool titleRetrieveApplicationMetadataByTitleId(u64 title_id, TitleApplicationMetadata *out);
|
|
|
|
static bool titleOpenNcmDatabases(void);
|
|
static void titleCloseNcmDatabases(void);
|
|
|
|
static bool titleOpenNcmStorages(void);
|
|
static void titleCloseNcmStorages(void);
|
|
|
|
static bool titleOpenNcmDatabaseAndStorageFromGameCard(void);
|
|
static void titleCloseNcmDatabaseAndStorageFromGameCard(void);
|
|
|
|
static bool titleLoadPersistentStorageTitleInfo(void);
|
|
static bool titleGenerateTitleInfoFromStorage(u8 storage_id);
|
|
static bool titleGetContentInfosFromTitle(u8 storage_id, const NcmContentMetaKey *meta_key, NcmContentInfo **out_content_infos, u32 *out_content_count);
|
|
static void titleUpdateTitleInfoLinkedLists(void);
|
|
|
|
static bool titleCreateGameCardInfoThread(void);
|
|
static void titleDestroyGameCardInfoThread(void);
|
|
static void titleGameCardInfoThreadFunc(void *arg);
|
|
|
|
static bool titleRefreshGameCardTitleInfo(void);
|
|
static void titleRemoveGameCardTitleInfoEntries(void);
|
|
|
|
static bool titleIsUserApplicationContentAvailable(u64 app_id);
|
|
static TitleInfo *_titleGetInfoFromStorageByTitleId(u8 storage_id, u64 title_id, bool lock);
|
|
|
|
static int titleSystemTitleMetadataEntrySortFunction(const void *a, const void *b);
|
|
static int titleUserApplicationMetadataEntrySortFunction(const void *a, const void *b);
|
|
static int titleOrphanTitleInfoSortFunction(const void *a, const void *b);
|
|
|
|
bool titleInitialize(void)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
bool ret = g_titleInterfaceInit;
|
|
if (ret) goto end;
|
|
|
|
/* Allocate memory for the ns application control data. */
|
|
/* This will be used each time we need to retrieve the metadata from an application. */
|
|
g_nsAppControlData = calloc(1, sizeof(NsApplicationControlData));
|
|
if (!g_nsAppControlData)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for the ns application control data!");
|
|
goto end;
|
|
}
|
|
|
|
/* Generate application metadata entries from hardcoded system titles, since we can't retrieve their names via ns. */
|
|
if (!titleGenerateMetadataEntriesFromSystemTitles())
|
|
{
|
|
LOG_MSG("Failed to generate application metadata from hardcoded system titles!");
|
|
goto end;
|
|
}
|
|
|
|
/* Generate application metadata entries from ns records. */
|
|
/* Theoretically speaking, we should only need to do this once. */
|
|
/* However, if any new gamecard is inserted while the application is running, we *will* have to retrieve the metadata from its application(s). */
|
|
if (!titleGenerateMetadataEntriesFromNsRecords())
|
|
{
|
|
LOG_MSG("Failed to generate application metadata from ns records!");
|
|
goto end;
|
|
}
|
|
|
|
/* Open eMMC System, eMMC User and SD card ncm databases. */
|
|
if (!titleOpenNcmDatabases())
|
|
{
|
|
LOG_MSG("Failed to open ncm databases!");
|
|
goto end;
|
|
}
|
|
|
|
/* Open eMMC System, eMMC User and SD card ncm storages. */
|
|
if (!titleOpenNcmStorages())
|
|
{
|
|
LOG_MSG("Failed to open ncm storages!");
|
|
goto end;
|
|
}
|
|
|
|
/* Load title info by retrieving content meta keys from available eMMC System, eMMC User and SD card titles. */
|
|
if (!titleLoadPersistentStorageTitleInfo())
|
|
{
|
|
LOG_MSG("Failed to load persistent storage title info!");
|
|
goto end;
|
|
}
|
|
|
|
/* Create user-mode exit event. */
|
|
ueventCreate(&g_titleGameCardInfoThreadExitEvent, true);
|
|
|
|
/* Retrieve gamecard status change user event. */
|
|
g_titleGameCardStatusChangeUserEvent = gamecardGetStatusChangeUserEvent();
|
|
if (!g_titleGameCardStatusChangeUserEvent)
|
|
{
|
|
LOG_MSG("Failed to retrieve gamecard status change user event!");
|
|
goto end;
|
|
}
|
|
|
|
/* Create user-mode gamecard update info event. */
|
|
ueventCreate(&g_titleGameCardUpdateInfoUserEvent, true);
|
|
|
|
/* Create gamecard title info thread. */
|
|
if (!(g_titleGameCardInfoThreadCreated = titleCreateGameCardInfoThread())) goto end;
|
|
|
|
ret = g_titleInterfaceInit = true;
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void titleExit(void)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
/* Destroy gamecard detection thread. */
|
|
if (g_titleGameCardInfoThreadCreated)
|
|
{
|
|
titleDestroyGameCardInfoThread();
|
|
g_titleGameCardInfoThreadCreated = false;
|
|
}
|
|
|
|
/* Free title info. */
|
|
titleFreeTitleInfo();
|
|
|
|
/* Close gamecard ncm database and storage (if needed). */
|
|
titleCloseNcmDatabaseAndStorageFromGameCard();
|
|
|
|
/* Close eMMC System, eMMC User and SD card ncm storages. */
|
|
titleCloseNcmStorages();
|
|
|
|
/* Close eMMC System, eMMC User and SD card ncm databases. */
|
|
titleCloseNcmDatabases();
|
|
|
|
/* Free application metadata. */
|
|
titleFreeApplicationMetadata();
|
|
|
|
/* Free ns application control data. */
|
|
if (g_nsAppControlData) free(g_nsAppControlData);
|
|
|
|
g_titleInterfaceInit = false;
|
|
|
|
mutexUnlock(&g_titleMutex);
|
|
}
|
|
|
|
NcmContentMetaDatabase *titleGetNcmDatabaseByStorageId(u8 storage_id)
|
|
{
|
|
NcmContentMetaDatabase *ncm_db = NULL;
|
|
|
|
switch(storage_id)
|
|
{
|
|
case NcmStorageId_GameCard:
|
|
ncm_db = &g_ncmDbGameCard;
|
|
break;
|
|
case NcmStorageId_BuiltInSystem:
|
|
ncm_db = &g_ncmDbEmmcSystem;
|
|
break;
|
|
case NcmStorageId_BuiltInUser:
|
|
ncm_db = &g_ncmDbEmmcUser;
|
|
break;
|
|
case NcmStorageId_SdCard:
|
|
ncm_db = &g_ncmDbSdCard;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ncm_db;
|
|
}
|
|
|
|
NcmContentStorage *titleGetNcmStorageByStorageId(u8 storage_id)
|
|
{
|
|
NcmContentStorage *ncm_storage = NULL;
|
|
|
|
switch(storage_id)
|
|
{
|
|
case NcmStorageId_GameCard:
|
|
ncm_storage = &g_ncmStorageGameCard;
|
|
break;
|
|
case NcmStorageId_BuiltInSystem:
|
|
ncm_storage = &g_ncmStorageEmmcSystem;
|
|
break;
|
|
case NcmStorageId_BuiltInUser:
|
|
ncm_storage = &g_ncmStorageEmmcUser;
|
|
break;
|
|
case NcmStorageId_SdCard:
|
|
ncm_storage = &g_ncmStorageSdCard;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ncm_storage;
|
|
}
|
|
|
|
TitleApplicationMetadata **titleGetApplicationMetadataEntries(bool is_system, u32 *out_count)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
u32 start_idx = (is_system ? 0 : g_systemTitlesCount);
|
|
u32 max_val = (is_system ? g_systemTitlesCount : g_appMetadataCount);
|
|
|
|
u32 app_count = 0;
|
|
TitleApplicationMetadata **app_metadata = NULL, **tmp_app_metadata = NULL;
|
|
|
|
if (!g_titleInterfaceInit || !g_appMetadata || !*g_appMetadata || (is_system && g_appMetadataCount < g_systemTitlesCount) || (!is_system && g_appMetadataCount == g_systemTitlesCount) || !out_count)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
for(u32 i = start_idx; i < max_val; i++)
|
|
{
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[i];
|
|
if (!cur_app_metadata) continue;
|
|
|
|
/* Skip current metadata entry if content data for this title isn't available. */
|
|
if ((is_system && !_titleGetInfoFromStorageByTitleId(NcmStorageId_BuiltInSystem, cur_app_metadata->title_id, false)) || \
|
|
(!is_system && !titleIsUserApplicationContentAvailable(cur_app_metadata->title_id))) continue;
|
|
|
|
/* Reallocate application metadata pointer array. */
|
|
tmp_app_metadata = realloc(app_metadata, (app_count + 1) * sizeof(TitleApplicationMetadata*));
|
|
if (!tmp_app_metadata)
|
|
{
|
|
LOG_MSG("Failed to reallocate application metadata pointer array!");
|
|
if (app_metadata) free(app_metadata);
|
|
app_metadata = NULL;
|
|
goto end;
|
|
}
|
|
|
|
app_metadata = tmp_app_metadata;
|
|
tmp_app_metadata = NULL;
|
|
|
|
/* Set current pointer and increase counter. */
|
|
app_metadata[app_count++] = cur_app_metadata;
|
|
}
|
|
|
|
/* Update output counter. */
|
|
*out_count = app_count;
|
|
|
|
if (!app_metadata || !app_count) LOG_MSG("No content data found for %s!", is_system ? "system titles" : "user applications");
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
return app_metadata;
|
|
}
|
|
|
|
TitleInfo *titleGetInfoFromStorageByTitleId(u8 storage_id, u64 title_id)
|
|
{
|
|
return _titleGetInfoFromStorageByTitleId(storage_id, title_id, true);
|
|
}
|
|
|
|
bool titleGetUserApplicationData(u64 app_id, TitleUserApplicationData *out)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
bool success = false;
|
|
|
|
if (!g_titleInterfaceInit || !g_titleInfo || !*g_titleInfo || !g_titleInfoCount || !app_id || !out)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
/* Clear output. */
|
|
memset(out, 0, sizeof(TitleUserApplicationData));
|
|
|
|
/* Get first user application title info. */
|
|
out->app_info = _titleGetInfoFromStorageByTitleId(NcmStorageId_Any, app_id, false);
|
|
|
|
/* Get first patch title info. */
|
|
out->patch_info = _titleGetInfoFromStorageByTitleId(NcmStorageId_Any, titleGetPatchIdByApplicationId(app_id), false);
|
|
|
|
/* Get first add-on content title info. */
|
|
for(u32 i = g_titleInfoBuiltInUserStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *title_info = g_titleInfo[i];
|
|
if (title_info && title_info->meta_key.type == NcmContentMetaType_AddOnContent && titleCheckIfAddOnContentIdBelongsToApplicationId(app_id, title_info->meta_key.id))
|
|
{
|
|
out->aoc_info = title_info;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Check retrieved title info. */
|
|
success = (out->app_info || out->patch_info || out->aoc_info);
|
|
if (!success)
|
|
{
|
|
LOG_MSG("Failed to retrieve user application data for ID \"%016lX\"!", app_id);
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
return success;
|
|
}
|
|
|
|
bool titleAreOrphanTitlesAvailable(void)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
bool ret = (g_titleInterfaceInit && g_orphanTitleInfo && *g_orphanTitleInfo && g_orphanTitleInfoCount > 0);
|
|
mutexUnlock(&g_titleMutex);
|
|
return ret;
|
|
}
|
|
|
|
TitleInfo **titleGetInfoFromOrphanTitles(u32 *out_count)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
TitleInfo **orphan_info = NULL;
|
|
|
|
if (!g_titleInterfaceInit || !g_titleInfo || !*g_titleInfo || !g_titleInfoCount || !g_orphanTitleInfo || !*g_orphanTitleInfo || !g_orphanTitleInfoCount || !out_count)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
/* Allocate orphan title info pointer array. */
|
|
orphan_info = calloc(g_orphanTitleInfoCount, sizeof(TitleInfo*));
|
|
if (!orphan_info)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for orphan title info pointer array!");
|
|
goto end;
|
|
}
|
|
|
|
/* Get pointers to orphan title info entries. */
|
|
for(u32 i = 0; i < g_orphanTitleInfoCount; i++) orphan_info[i] = g_orphanTitleInfo[i];
|
|
|
|
/* Update output counter. */
|
|
*out_count = g_orphanTitleInfoCount;
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
return orphan_info;
|
|
}
|
|
|
|
bool titleIsGameCardInfoUpdated(void)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
/* Check if the gamecard thread detected a gamecard status change. */
|
|
bool ret = (g_titleInterfaceInit && g_titleGameCardInfoThreadCreated && g_titleGameCardInfoUpdated);
|
|
if (!ret) goto end;
|
|
|
|
/* Signal the gamecard update info user event. */
|
|
ueventSignal(&g_titleGameCardUpdateInfoUserEvent);
|
|
|
|
/* Wait for the gamecard thread to wake us up. */
|
|
condvarWait(&g_gameCardCondVar, &g_titleMutex);
|
|
|
|
/* Update output value and gamecard info updated flag (if needed). */
|
|
ret = g_titleGameCardInfoUpdated;
|
|
if (ret) g_titleGameCardInfoUpdated = false;
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
return ret;
|
|
}
|
|
|
|
char *titleGenerateFileName(const TitleInfo *title_info, u8 name_convention, u8 illegal_char_replace_type)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
char *filename = NULL;
|
|
char title_name[0x400] = {0};
|
|
|
|
if (!title_info || title_info->meta_key.type < NcmContentMetaType_Application || title_info->meta_key.type > NcmContentMetaType_Delta || name_convention > TitleFileNameConvention_IdAndVersionOnly || \
|
|
(name_convention == TitleFileNameConvention_Full && illegal_char_replace_type > TitleFileNameIllegalCharReplaceType_KeepAsciiCharsOnly))
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
u8 type = (title_info->meta_key.type - 0x80);
|
|
|
|
/* Generate filename for this title. */
|
|
if (name_convention == TitleFileNameConvention_Full)
|
|
{
|
|
if (title_info->app_metadata && *(title_info->app_metadata->lang_entry.name))
|
|
{
|
|
sprintf(title_name, "%s ", title_info->app_metadata->lang_entry.name);
|
|
if (illegal_char_replace_type) utilsReplaceIllegalCharacters(title_name, illegal_char_replace_type == TitleFileNameIllegalCharReplaceType_KeepAsciiCharsOnly);
|
|
}
|
|
|
|
sprintf(title_name + strlen(title_name), "[%016lX][v%u][%s]", title_info->meta_key.id, title_info->meta_key.version, g_filenameTypeStrings[type]);
|
|
} else
|
|
if (name_convention == TitleFileNameConvention_IdAndVersionOnly)
|
|
{
|
|
sprintf(title_name, "%016lX_v%u_%s", title_info->meta_key.id, title_info->meta_key.version, g_filenameTypeStrings[type]);
|
|
}
|
|
|
|
/* Duplicate generated filename. */
|
|
filename = strdup(title_name);
|
|
if (!filename) LOG_MSG("Failed to duplicate generated filename!");
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
return filename;
|
|
}
|
|
|
|
char *titleGenerateGameCardFileName(u8 name_convention, u8 illegal_char_replace_type)
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
|
|
size_t cur_filename_len = 0;
|
|
char *filename = NULL, *tmp_filename = NULL;
|
|
char app_name[0x400] = {0};
|
|
|
|
if (!g_titleInterfaceInit || !g_titleInfo || !*g_titleInfo || !g_titleInfoCount || !g_titleGameCardAvailable || !g_titleInfoGameCardCount || \
|
|
name_convention > TitleFileNameConvention_IdAndVersionOnly || (name_convention == TitleFileNameConvention_Full && \
|
|
illegal_char_replace_type > TitleFileNameIllegalCharReplaceType_KeepAsciiCharsOnly))
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
for(u32 i = g_titleInfoGameCardStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *app_info = g_titleInfo[i];
|
|
if (!app_info || app_info->meta_key.type != NcmContentMetaType_Application) continue;
|
|
|
|
u32 app_version = app_info->meta_key.version;
|
|
|
|
/* Check if the inserted gamecard holds any bundled patches for the current user application. */
|
|
/* If so, we'll use the highest patch version available as part of the filename. */
|
|
for(u32 j = g_titleInfoGameCardStartIndex; j < g_titleInfoCount; j++)
|
|
{
|
|
if (j == i) continue;
|
|
|
|
TitleInfo *patch_info = g_titleInfo[j];
|
|
if (!patch_info || patch_info->meta_key.type != NcmContentMetaType_Patch || !titleCheckIfPatchIdBelongsToApplicationId(app_info->meta_key.id, patch_info->meta_key.id) || \
|
|
patch_info->meta_key.version <= app_version) continue;
|
|
|
|
app_version = patch_info->meta_key.version;
|
|
}
|
|
|
|
/* Generate current user application name. */
|
|
*app_name = '\0';
|
|
|
|
if (name_convention == TitleFileNameConvention_Full)
|
|
{
|
|
if (cur_filename_len) strcat(app_name, " + ");
|
|
|
|
if (app_info->app_metadata && *(app_info->app_metadata->lang_entry.name))
|
|
{
|
|
sprintf(app_name + strlen(app_name), "%s ", app_info->app_metadata->lang_entry.name);
|
|
if (illegal_char_replace_type) utilsReplaceIllegalCharacters(app_name, illegal_char_replace_type == TitleFileNameIllegalCharReplaceType_KeepAsciiCharsOnly);
|
|
}
|
|
|
|
sprintf(app_name + strlen(app_name), "[%016lX][v%u]", app_info->meta_key.id, app_version);
|
|
} else
|
|
if (name_convention == TitleFileNameConvention_IdAndVersionOnly)
|
|
{
|
|
if (cur_filename_len) strcat(app_name, "+");
|
|
sprintf(app_name + strlen(app_name), "%016lX_v%u", app_info->meta_key.id, app_version);
|
|
}
|
|
|
|
/* Reallocate output buffer. */
|
|
size_t app_name_len = strlen(app_name);
|
|
|
|
tmp_filename = realloc(filename, (cur_filename_len + app_name_len + 1) * sizeof(char));
|
|
if (!tmp_filename)
|
|
{
|
|
LOG_MSG("Failed to reallocate filename buffer!");
|
|
if (filename) free(filename);
|
|
filename = NULL;
|
|
goto end;
|
|
}
|
|
|
|
filename = tmp_filename;
|
|
tmp_filename = NULL;
|
|
|
|
/* Concatenate current user application name. */
|
|
filename[cur_filename_len] = '\0';
|
|
strcat(filename, app_name);
|
|
cur_filename_len += app_name_len;
|
|
}
|
|
|
|
if (!filename) LOG_MSG("Error: the inserted gamecard doesn't hold any user applications!");
|
|
|
|
end:
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
/* Fallback string if any errors occur. */
|
|
/* This function is guaranteed to fail with Kiosk / Quest gamecards, so that's why this is needed. */
|
|
if (!filename) filename = strdup("gamecard");
|
|
|
|
return filename;
|
|
}
|
|
|
|
const char *titleGetNcmContentTypeName(u8 content_type)
|
|
{
|
|
return (content_type <= NcmContentType_DeltaFragment ? g_titleNcmContentTypeNames[content_type] : NULL);
|
|
}
|
|
|
|
const char *titleGetNcmContentMetaTypeName(u8 content_meta_type)
|
|
{
|
|
if ((content_meta_type > NcmContentMetaType_BootImagePackageSafe && content_meta_type < NcmContentMetaType_Application) || content_meta_type > NcmContentMetaType_Delta) return NULL;
|
|
return (content_meta_type <= NcmContentMetaType_BootImagePackageSafe ? g_titleNcmContentMetaTypeNames[content_meta_type] : g_titleNcmContentMetaTypeNames[content_meta_type - 0x7A]);
|
|
}
|
|
|
|
NX_INLINE void titleFreeApplicationMetadata(void)
|
|
{
|
|
if (g_appMetadata)
|
|
{
|
|
for(u32 i = 0; i < g_appMetadataCount; i++)
|
|
{
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[i];
|
|
if (cur_app_metadata)
|
|
{
|
|
if (cur_app_metadata->icon) free(cur_app_metadata->icon);
|
|
free(cur_app_metadata);
|
|
}
|
|
}
|
|
|
|
free(g_appMetadata);
|
|
g_appMetadata = NULL;
|
|
}
|
|
|
|
g_appMetadataCount = 0;
|
|
}
|
|
|
|
static bool titleReallocateApplicationMetadata(u32 extra_app_count, bool free_entries)
|
|
{
|
|
if (free_entries && !g_appMetadata)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
return false;
|
|
}
|
|
|
|
TitleApplicationMetadata **tmp_app_metadata = NULL;
|
|
u32 realloc_app_count = (!free_entries ? (g_appMetadataCount + extra_app_count) : g_appMetadataCount);
|
|
bool success = false;
|
|
|
|
if (free_entries)
|
|
{
|
|
/* Free previously allocated application metadata entries. */
|
|
for(u32 i = 0; i <= extra_app_count; i++)
|
|
{
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[g_appMetadataCount + i];
|
|
if (cur_app_metadata)
|
|
{
|
|
if (cur_app_metadata->icon) free(cur_app_metadata->icon);
|
|
free(cur_app_metadata);
|
|
cur_app_metadata = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (realloc_app_count)
|
|
{
|
|
/* Reallocate application metadata pointer array. */
|
|
tmp_app_metadata = realloc(g_appMetadata, realloc_app_count * sizeof(TitleApplicationMetadata*));
|
|
if (tmp_app_metadata)
|
|
{
|
|
/* Update application metadata pointer. */
|
|
g_appMetadata = tmp_app_metadata;
|
|
tmp_app_metadata = NULL;
|
|
|
|
/* Clear new application metadata pointer array area (if needed). */
|
|
if (!free_entries && extra_app_count) memset(g_appMetadata + g_appMetadataCount, 0, extra_app_count * sizeof(TitleApplicationMetadata*));
|
|
} else {
|
|
LOG_MSG("Failed to reallocate application metadata pointer array! (%u element[s]).", realloc_app_count);
|
|
goto end;
|
|
}
|
|
} else {
|
|
/* Free application metadata pointer array. */
|
|
free(g_appMetadata);
|
|
g_appMetadata = NULL;
|
|
}
|
|
|
|
/* Update flag. */
|
|
success = true;
|
|
|
|
end:
|
|
return success;
|
|
}
|
|
|
|
NX_INLINE void titleFreeTitleInfo(void)
|
|
{
|
|
if (g_titleInfo)
|
|
{
|
|
for(u32 i = 0; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *cur_title_info = g_titleInfo[i];
|
|
if (cur_title_info)
|
|
{
|
|
if (cur_title_info->content_infos) free(cur_title_info->content_infos);
|
|
free(cur_title_info);
|
|
}
|
|
}
|
|
|
|
free(g_titleInfo);
|
|
g_titleInfo = NULL;
|
|
}
|
|
|
|
titleFreeOrphanTitleInfo();
|
|
|
|
g_titleInfoCount = g_titleInfoBuiltInSystemCount = 0;
|
|
g_titleInfoBuiltInUserStartIndex = g_titleInfoBuiltInUserCount = 0;
|
|
g_titleInfoSdCardStartIndex = g_titleInfoSdCardCount = 0;
|
|
g_titleInfoGameCardStartIndex = g_titleInfoGameCardCount = 0;
|
|
}
|
|
|
|
static bool titleReallocateTitleInfo(u32 extra_title_count, bool free_entries)
|
|
{
|
|
if (free_entries && !g_titleInfo)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
return false;
|
|
}
|
|
|
|
TitleInfo **tmp_title_info = NULL;
|
|
u32 realloc_title_count = (!free_entries ? (g_titleInfoCount + extra_title_count) : g_titleInfoCount);
|
|
bool success = false;
|
|
|
|
if (free_entries)
|
|
{
|
|
/* Free previously allocated title info entries. */
|
|
for(u32 i = 0; i <= extra_title_count; i++)
|
|
{
|
|
TitleInfo *cur_title_info = g_titleInfo[g_titleInfoCount + i];
|
|
if (cur_title_info)
|
|
{
|
|
if (cur_title_info->content_infos) free(cur_title_info->content_infos);
|
|
free(cur_title_info);
|
|
cur_title_info = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (realloc_title_count)
|
|
{
|
|
/* Reallocate title info pointer array. */
|
|
tmp_title_info = realloc(g_titleInfo, realloc_title_count * sizeof(TitleInfo*));
|
|
if (tmp_title_info)
|
|
{
|
|
/* Update title info pointer. */
|
|
g_titleInfo = tmp_title_info;
|
|
tmp_title_info = NULL;
|
|
|
|
/* Clear new title info pointer array area (if needed). */
|
|
if (!free_entries && extra_title_count) memset(g_titleInfo + g_titleInfoCount, 0, extra_title_count * sizeof(TitleInfo*));
|
|
} else {
|
|
LOG_MSG("Failed to reallocate title info pointer array! (%u element[s]).", realloc_title_count);
|
|
goto end;
|
|
}
|
|
} else {
|
|
/* Free title info pointer array. */
|
|
free(g_titleInfo);
|
|
g_titleInfo = NULL;
|
|
}
|
|
|
|
/* Update flag. */
|
|
success = true;
|
|
|
|
end:
|
|
return success;
|
|
}
|
|
|
|
NX_INLINE void titleFreeOrphanTitleInfo(void)
|
|
{
|
|
if (g_orphanTitleInfo)
|
|
{
|
|
free(g_orphanTitleInfo);
|
|
g_orphanTitleInfo = NULL;
|
|
}
|
|
|
|
g_orphanTitleInfoCount = 0;
|
|
}
|
|
|
|
static void titleAddOrphanTitleInfoEntry(TitleInfo *orphan_title)
|
|
{
|
|
if (!orphan_title) return;
|
|
|
|
/* Reallocate orphan title info pointer array. */
|
|
TitleInfo **tmp_orphan_info = realloc(g_orphanTitleInfo, (g_orphanTitleInfoCount + 1) * sizeof(TitleInfo*));
|
|
if (!tmp_orphan_info)
|
|
{
|
|
LOG_MSG("Failed to reallocate orphan title info pointer array!");
|
|
return;
|
|
}
|
|
|
|
g_orphanTitleInfo = tmp_orphan_info;
|
|
tmp_orphan_info = NULL;
|
|
|
|
/* Set orphan title info entry pointer. */
|
|
g_orphanTitleInfo[g_orphanTitleInfoCount++] = orphan_title;
|
|
|
|
/* Sort orphan title info entries by title ID. */
|
|
if (g_orphanTitleInfoCount > 1) qsort(g_orphanTitleInfo, g_orphanTitleInfoCount, sizeof(TitleInfo*), &titleOrphanTitleInfoSortFunction);
|
|
}
|
|
|
|
NX_INLINE TitleApplicationMetadata *titleFindApplicationMetadataByTitleId(u64 title_id)
|
|
{
|
|
if (!g_appMetadata || !*g_appMetadata || !g_appMetadataCount || !title_id) return NULL;
|
|
|
|
for(u32 i = 0; i < g_appMetadataCount; i++)
|
|
{
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[i];
|
|
if (cur_app_metadata && cur_app_metadata->title_id == title_id) return cur_app_metadata;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static bool titleGenerateMetadataEntriesFromSystemTitles(void)
|
|
{
|
|
u32 extra_app_count = 0;
|
|
bool success = false;
|
|
|
|
/* Reallocate application metadata pointer array. */
|
|
if (!titleReallocateApplicationMetadata(g_systemTitlesCount, false))
|
|
{
|
|
LOG_MSG("Failed to reallocate application metadata pointer array for system titles!");
|
|
return false;
|
|
}
|
|
|
|
/* Fill new application metadata entries. */
|
|
for(extra_app_count = 0; extra_app_count < g_systemTitlesCount; extra_app_count++)
|
|
{
|
|
/* Allocate memory for the current entry. */
|
|
TitleApplicationMetadata *cur_app_metadata = calloc(1, sizeof(TitleApplicationMetadata));
|
|
if (!cur_app_metadata)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for application metadata entry #%u!", extra_app_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Fill information. */
|
|
const SystemTitleName *system_title = &(g_systemTitles[extra_app_count]);
|
|
cur_app_metadata->title_id = system_title->title_id;
|
|
sprintf(cur_app_metadata->lang_entry.name, system_title->name);
|
|
|
|
/* Set application metadata entry pointer. */
|
|
g_appMetadata[g_appMetadataCount + extra_app_count] = cur_app_metadata;
|
|
}
|
|
|
|
/* Sort metadata entries by title ID. */
|
|
if (g_systemTitlesCount > 1) qsort(g_appMetadata + g_appMetadataCount, g_systemTitlesCount, sizeof(TitleApplicationMetadata*), &titleSystemTitleMetadataEntrySortFunction);
|
|
|
|
/* Update application metadata count. */
|
|
g_appMetadataCount += g_systemTitlesCount;
|
|
|
|
/* Update flag. */
|
|
success = true;
|
|
|
|
end:
|
|
/* Free previously allocated application metadata pointers. Ignore return value. */
|
|
if (!success) titleReallocateApplicationMetadata(extra_app_count, true);
|
|
|
|
return success;
|
|
}
|
|
|
|
static bool titleGenerateMetadataEntriesFromNsRecords(void)
|
|
{
|
|
Result rc = 0;
|
|
|
|
NsApplicationRecord *app_records = NULL;
|
|
u32 app_records_count = 0, extra_app_count = 0;
|
|
|
|
bool success = false, free_entries = false;
|
|
|
|
/* Allocate memory for the NS application records. */
|
|
app_records = calloc(NS_APPLICATION_RECORD_LIMIT, sizeof(NsApplicationRecord));
|
|
if (!app_records)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for NS application records!");
|
|
return false;
|
|
}
|
|
|
|
/* Retrieve NS application records. */
|
|
rc = nsListApplicationRecord(app_records, NS_APPLICATION_RECORD_LIMIT, 0, (s32*)&app_records_count);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("nsListApplicationRecord failed! (0x%08X).", rc);
|
|
goto end;
|
|
}
|
|
|
|
/* Return right away if no records were retrieved. */
|
|
if (!app_records_count)
|
|
{
|
|
success = true;
|
|
goto end;
|
|
}
|
|
|
|
/* Reallocate application metadata pointer array. */
|
|
if (!titleReallocateApplicationMetadata(app_records_count, false))
|
|
{
|
|
LOG_MSG("Failed to reallocate application metadata pointer array for NS records!");
|
|
goto end;
|
|
}
|
|
|
|
free_entries = true;
|
|
|
|
/* Retrieve application metadata for each NS application record. */
|
|
for(u32 i = 0; i < app_records_count; i++)
|
|
{
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[g_appMetadataCount + extra_app_count];
|
|
if (!cur_app_metadata)
|
|
{
|
|
/* Allocate memory for a new application metadata entry. */
|
|
cur_app_metadata = calloc(1, sizeof(TitleApplicationMetadata));
|
|
if (!cur_app_metadata)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for application metadata entry #%u! (%u / %u).", extra_app_count, i + 1, app_records_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Set application metadata entry pointer. */
|
|
g_appMetadata[g_appMetadataCount + extra_app_count] = cur_app_metadata;
|
|
}
|
|
|
|
/* Retrieve application metadata. */
|
|
if (!titleRetrieveApplicationMetadataByTitleId(app_records[i].application_id, cur_app_metadata)) continue;
|
|
|
|
/* Increase extra application metadata counter. */
|
|
extra_app_count++;
|
|
}
|
|
|
|
/* Check retrieved application metadata count. */
|
|
if (!extra_app_count)
|
|
{
|
|
LOG_MSG("Unable to retrieve application metadata from NS application records! (%u element[s]).", app_records_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Sort application metadata entries by name. */
|
|
if (extra_app_count > 1) qsort(g_appMetadata + g_appMetadataCount, extra_app_count, sizeof(TitleApplicationMetadata*), &titleUserApplicationMetadataEntrySortFunction);
|
|
|
|
/* Update application metadata count. */
|
|
g_appMetadataCount += extra_app_count;
|
|
|
|
/* Free extra allocated pointers if we didn't use them. */
|
|
if (extra_app_count < app_records_count) titleReallocateApplicationMetadata(0, false);
|
|
|
|
/* Update flag. */
|
|
success = true;
|
|
|
|
end:
|
|
if (app_records) free(app_records);
|
|
|
|
/* Free previously allocated application metadata pointers. Ignore return value. */
|
|
if (!success && free_entries) titleReallocateApplicationMetadata(extra_app_count, true);
|
|
|
|
return success;
|
|
}
|
|
|
|
static bool titleRetrieveApplicationMetadataByTitleId(u64 title_id, TitleApplicationMetadata *out)
|
|
{
|
|
if (!g_nsAppControlData || !title_id || !out)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
return false;
|
|
}
|
|
|
|
Result rc = 0;
|
|
u64 write_size = 0;
|
|
NacpLanguageEntry *lang_entry = NULL;
|
|
|
|
u32 icon_size = 0;
|
|
u8 *icon = NULL;
|
|
|
|
/* Retrieve ns application control data. */
|
|
rc = nsGetApplicationControlData(NsApplicationControlSource_Storage, title_id, g_nsAppControlData, sizeof(NsApplicationControlData), &write_size);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("nsGetApplicationControlData failed for title ID \"%016lX\"! (0x%08X).", rc, title_id);
|
|
return false;
|
|
}
|
|
|
|
if (write_size < sizeof(NacpStruct))
|
|
{
|
|
LOG_MSG("Retrieved application control data buffer is too small! (0x%lX).", write_size);
|
|
return false;
|
|
}
|
|
|
|
/* Get language entry. */
|
|
rc = nacpGetLanguageEntry(&(g_nsAppControlData->nacp), &lang_entry);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("nacpGetLanguageEntry failed! (0x%08X).", rc);
|
|
return false;
|
|
}
|
|
|
|
/* Get icon. */
|
|
icon_size = (u32)(write_size - sizeof(NacpStruct));
|
|
if (icon_size)
|
|
{
|
|
icon = malloc(icon_size);
|
|
if (!icon)
|
|
{
|
|
LOG_MSG("Error allocating memory for the icon buffer! (0x%X).", icon_size);
|
|
return false;
|
|
}
|
|
|
|
memcpy(icon, g_nsAppControlData->icon, icon_size);
|
|
}
|
|
|
|
/* Copy data. */
|
|
out->title_id = title_id;
|
|
|
|
memcpy(&(out->lang_entry), lang_entry, sizeof(NacpLanguageEntry));
|
|
utilsTrimString(out->lang_entry.name);
|
|
utilsTrimString(out->lang_entry.author);
|
|
|
|
out->icon_size = icon_size;
|
|
out->icon = icon;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool titleOpenNcmDatabases(void)
|
|
{
|
|
Result rc = 0;
|
|
NcmContentMetaDatabase *ncm_db = NULL;
|
|
|
|
for(u8 i = NcmStorageId_BuiltInSystem; i <= NcmStorageId_SdCard; i++)
|
|
{
|
|
/* Retrieve ncm database pointer. */
|
|
ncm_db = titleGetNcmDatabaseByStorageId(i);
|
|
if (!ncm_db)
|
|
{
|
|
LOG_MSG("Failed to retrieve ncm database pointer for storage ID %u!", i);
|
|
return false;
|
|
}
|
|
|
|
/* Check if the ncm database handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_db->s))) continue;
|
|
|
|
/* Open ncm database. */
|
|
rc = ncmOpenContentMetaDatabase(ncm_db, i);
|
|
if (R_FAILED(rc))
|
|
{
|
|
/* If the SD card is mounted, but it isn't currently being used by HOS, 0x21005 will be returned, so we'll just filter this particular error and continue. */
|
|
/* This can occur when using the "Nintendo" directory from a different console, or when the "sdmc:/Nintendo/Contents/private" file is corrupted. */
|
|
LOG_MSG("ncmOpenContentMetaDatabase failed for storage ID %u! (0x%08X).", i, rc);
|
|
if (i == NcmStorageId_SdCard && rc == 0x21005) continue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void titleCloseNcmDatabases(void)
|
|
{
|
|
NcmContentMetaDatabase *ncm_db = NULL;
|
|
|
|
for(u8 i = NcmStorageId_BuiltInSystem; i <= NcmStorageId_SdCard; i++)
|
|
{
|
|
/* Retrieve ncm database pointer. */
|
|
ncm_db = titleGetNcmDatabaseByStorageId(i);
|
|
if (!ncm_db) continue;
|
|
|
|
/* Check if the ncm database handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_db->s))) ncmContentMetaDatabaseClose(ncm_db);
|
|
}
|
|
}
|
|
|
|
static bool titleOpenNcmStorages(void)
|
|
{
|
|
Result rc = 0;
|
|
NcmContentStorage *ncm_storage = NULL;
|
|
|
|
for(u8 i = NcmStorageId_BuiltInSystem; i <= NcmStorageId_SdCard; i++)
|
|
{
|
|
/* Retrieve ncm storage pointer. */
|
|
ncm_storage = titleGetNcmStorageByStorageId(i);
|
|
if (!ncm_storage)
|
|
{
|
|
LOG_MSG("Failed to retrieve ncm storage pointer for storage ID %u!", i);
|
|
return false;
|
|
}
|
|
|
|
/* Check if the ncm storage handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_storage->s))) continue;
|
|
|
|
/* Open ncm storage. */
|
|
rc = ncmOpenContentStorage(ncm_storage, i);
|
|
if (R_FAILED(rc))
|
|
{
|
|
/* If the SD card is mounted, but it isn't currently being used by HOS, 0x21005 will be returned, so we'll just filter this particular error and continue. */
|
|
/* This can occur when using the "Nintendo" directory from a different console, or when the "sdmc:/Nintendo/Contents/private" file is corrupted. */
|
|
LOG_MSG("ncmOpenContentStorage failed for storage ID %u! (0x%08X).", i, rc);
|
|
if (i == NcmStorageId_SdCard && rc == 0x21005) continue;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void titleCloseNcmStorages(void)
|
|
{
|
|
NcmContentStorage *ncm_storage = NULL;
|
|
|
|
for(u8 i = NcmStorageId_BuiltInSystem; i <= NcmStorageId_SdCard; i++)
|
|
{
|
|
/* Retrieve ncm storage pointer. */
|
|
ncm_storage = titleGetNcmStorageByStorageId(i);
|
|
if (!ncm_storage) continue;
|
|
|
|
/* Check if the ncm storage handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_storage->s))) ncmContentStorageClose(ncm_storage);
|
|
}
|
|
}
|
|
|
|
static bool titleOpenNcmDatabaseAndStorageFromGameCard(void)
|
|
{
|
|
Result rc = 0;
|
|
NcmContentMetaDatabase *ncm_db = &g_ncmDbGameCard;
|
|
NcmContentStorage *ncm_storage = &g_ncmStorageGameCard;
|
|
|
|
/* Open ncm database. */
|
|
rc = ncmOpenContentMetaDatabase(ncm_db, NcmStorageId_GameCard);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmOpenContentMetaDatabase failed! (0x%08X).", rc);
|
|
goto end;
|
|
}
|
|
|
|
/* Open ncm storage. */
|
|
rc = ncmOpenContentStorage(ncm_storage, NcmStorageId_GameCard);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmOpenContentStorage failed! (0x%08X).", rc);
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
return R_SUCCEEDED(rc);
|
|
}
|
|
|
|
static void titleCloseNcmDatabaseAndStorageFromGameCard(void)
|
|
{
|
|
NcmContentMetaDatabase *ncm_db = &g_ncmDbGameCard;
|
|
NcmContentStorage *ncm_storage = &g_ncmStorageGameCard;
|
|
|
|
/* Check if the ncm database handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_db->s))) ncmContentMetaDatabaseClose(ncm_db);
|
|
|
|
/* Check if the ncm storage handle has already been retrieved. */
|
|
if (serviceIsActive(&(ncm_storage->s))) ncmContentStorageClose(ncm_storage);
|
|
}
|
|
|
|
static bool titleLoadPersistentStorageTitleInfo(void)
|
|
{
|
|
/* Return right away if title info has already been retrieved. */
|
|
if ((g_titleInfo && *g_titleInfo) || g_titleInfoCount) return true;
|
|
|
|
for(u8 i = NcmStorageId_BuiltInSystem; i <= NcmStorageId_SdCard; i++)
|
|
{
|
|
u32 cur_title_count = 0;
|
|
|
|
/* Generate title info from the current storage. */
|
|
if (!titleGenerateTitleInfoFromStorage(i))
|
|
{
|
|
LOG_MSG("Failed to generate title info from storage ID %u!", i);
|
|
return false;
|
|
}
|
|
|
|
/* Update title info counters and indexes. */
|
|
switch(i)
|
|
{
|
|
case NcmStorageId_BuiltInSystem:
|
|
g_titleInfoBuiltInSystemCount = g_titleInfoCount;
|
|
cur_title_count = g_titleInfoBuiltInSystemCount;
|
|
break;
|
|
case NcmStorageId_BuiltInUser:
|
|
g_titleInfoBuiltInUserStartIndex = g_titleInfoBuiltInSystemCount;
|
|
g_titleInfoBuiltInUserCount = (g_titleInfoCount - g_titleInfoBuiltInUserStartIndex);
|
|
cur_title_count = g_titleInfoBuiltInUserCount;
|
|
break;
|
|
case NcmStorageId_SdCard:
|
|
g_titleInfoSdCardStartIndex = (g_titleInfoBuiltInUserStartIndex + g_titleInfoBuiltInUserCount);
|
|
g_titleInfoSdCardCount = (g_titleInfoCount - g_titleInfoSdCardStartIndex);
|
|
cur_title_count = g_titleInfoSdCardCount;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
LOG_MSG("Loaded info for %u title(s) from storage ID %u.", cur_title_count, i);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool titleGenerateTitleInfoFromStorage(u8 storage_id)
|
|
{
|
|
NcmContentMetaDatabase *ncm_db = NULL;
|
|
|
|
if (!(ncm_db = titleGetNcmDatabaseByStorageId(storage_id)) || !serviceIsActive(&(ncm_db->s)))
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
return false;
|
|
}
|
|
|
|
Result rc = 0;
|
|
|
|
u32 written = 0, total = 0, extra_title_count = 0;
|
|
NcmContentMetaKey *meta_keys = NULL, *meta_keys_tmp = NULL;
|
|
size_t meta_keys_size = sizeof(NcmContentMetaKey);
|
|
|
|
bool success = false, free_entries = false;
|
|
|
|
/* Allocate memory for the ncm application content meta keys. */
|
|
meta_keys = calloc(1, meta_keys_size);
|
|
if (!meta_keys)
|
|
{
|
|
LOG_MSG("Unable to allocate memory for the ncm application meta keys!");
|
|
goto end;
|
|
}
|
|
|
|
/* Get a full list of all titles available in this storage. */
|
|
/* Meta type '0' means all title types will be retrieved. */
|
|
rc = ncmContentMetaDatabaseList(ncm_db, (s32*)&total, (s32*)&written, meta_keys, 1, 0, 0, 0, UINT64_MAX, NcmContentInstallType_Full);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmContentMetaDatabaseList failed! (0x%08X) (first entry).", rc);
|
|
goto end;
|
|
}
|
|
|
|
/* Check if our application meta keys buffer was actually filled. */
|
|
/* If it wasn't, odds are there are no titles in this storage. */
|
|
if (!written || !total)
|
|
{
|
|
success = true;
|
|
goto end;
|
|
}
|
|
|
|
/* Check if we need to resize our application meta keys buffer. */
|
|
if (total > written)
|
|
{
|
|
/* Update application meta keys buffer size. */
|
|
meta_keys_size *= total;
|
|
|
|
/* Reallocate application meta keys buffer. */
|
|
meta_keys_tmp = realloc(meta_keys, meta_keys_size);
|
|
if (!meta_keys_tmp)
|
|
{
|
|
LOG_MSG("Unable to reallocate application meta keys buffer! (%u entries).", total);
|
|
goto end;
|
|
}
|
|
|
|
meta_keys = meta_keys_tmp;
|
|
meta_keys_tmp = NULL;
|
|
|
|
/* Issue call again. */
|
|
rc = ncmContentMetaDatabaseList(ncm_db, (s32*)&total, (s32*)&written, meta_keys, (s32)total, 0, 0, 0, UINT64_MAX, NcmContentInstallType_Full);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmContentMetaDatabaseList failed! (0x%08X) (%u %s).", rc, total, total > 1 ? "entries" : "entry");
|
|
goto end;
|
|
}
|
|
|
|
/* Safety check. */
|
|
if (written != total)
|
|
{
|
|
LOG_MSG("Application meta key count mismatch! (%u != %u).", written, total);
|
|
goto end;
|
|
}
|
|
}
|
|
|
|
/* Reallocate title info pointer array. */
|
|
if (!titleReallocateTitleInfo(total, false))
|
|
{
|
|
LOG_MSG("Failed to reallocate title info pointer array for storage ID %u!", storage_id);
|
|
goto end;
|
|
}
|
|
|
|
free_entries = true;
|
|
|
|
/* Fill new title info entries. */
|
|
for(u32 i = 0; i < total; i++)
|
|
{
|
|
u64 tmp_size = 0;
|
|
NcmContentMetaKey *cur_meta_key = &(meta_keys[i]);
|
|
|
|
TitleInfo *cur_title_info = g_titleInfo[g_titleInfoCount + extra_title_count];
|
|
if (!cur_title_info)
|
|
{
|
|
/* Allocate memory for a new entry. */
|
|
cur_title_info = calloc(1, sizeof(TitleInfo));
|
|
if (!cur_title_info)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for title info entry #%u! (%u / %u).", extra_title_count, i + 1, total);
|
|
goto end;
|
|
}
|
|
|
|
/* Set title info entry pointer. */
|
|
g_titleInfo[g_titleInfoCount + extra_title_count] = cur_title_info;
|
|
}
|
|
|
|
/* Get content infos. */
|
|
if (!titleGetContentInfosFromTitle(storage_id, cur_meta_key, &(cur_title_info->content_infos), &(cur_title_info->content_count)))
|
|
{
|
|
LOG_MSG("Failed to get content infos for title ID %016lX!", cur_meta_key->id);
|
|
continue;
|
|
}
|
|
|
|
/* Calculate title size. */
|
|
for(u32 j = 0; j < cur_title_info->content_count; j++)
|
|
{
|
|
titleConvertNcmContentSizeToU64(cur_title_info->content_infos[j].size, &tmp_size);
|
|
cur_title_info->size += tmp_size;
|
|
}
|
|
|
|
/* Fill information. */
|
|
cur_title_info->storage_id = storage_id;
|
|
memcpy(&(cur_title_info->meta_key), cur_meta_key, sizeof(NcmContentMetaKey));
|
|
cur_title_info->version.value = cur_title_info->meta_key.version;
|
|
utilsGenerateFormattedSizeString(cur_title_info->size, cur_title_info->size_str, sizeof(cur_title_info->size_str));
|
|
|
|
/* Retrieve application metadata. */
|
|
u64 app_id = (cur_title_info->meta_key.type <= NcmContentMetaType_Application ? cur_title_info->meta_key.id : \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_Patch ? titleGetApplicationIdByPatchId(cur_title_info->meta_key.id) : \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_AddOnContent ? titleGetApplicationIdByAddOnContentId(cur_title_info->meta_key.id) : \
|
|
titleGetApplicationIdByDeltaId(cur_title_info->meta_key.id))));
|
|
|
|
cur_title_info->app_metadata = titleFindApplicationMetadataByTitleId(app_id);
|
|
|
|
/* Increase extra title info counter. */
|
|
extra_title_count++;
|
|
}
|
|
|
|
/* Check retrieved title info count. */
|
|
if (!extra_title_count)
|
|
{
|
|
LOG_MSG("Unable to generate title info entries! (%u element[s]).", total);
|
|
goto end;
|
|
}
|
|
|
|
/* Update title info count. */
|
|
g_titleInfoCount += extra_title_count;
|
|
|
|
/* Free extra allocated pointers if we didn't use them. */
|
|
if (extra_title_count < total) titleReallocateTitleInfo(0, false);
|
|
|
|
/* Update linked lists for user applications, patches and add-on contents. */
|
|
/* This will also keep track of orphan titles - titles with no available application metadata. */
|
|
titleUpdateTitleInfoLinkedLists();
|
|
|
|
/* Update flag. */
|
|
success = true;
|
|
|
|
end:
|
|
if (meta_keys) free(meta_keys);
|
|
|
|
/* Free previously allocated title info pointers. Ignore return value. */
|
|
if (!success && free_entries) titleReallocateTitleInfo(extra_title_count, true);
|
|
|
|
return success;
|
|
}
|
|
|
|
static bool titleGetContentInfosFromTitle(u8 storage_id, const NcmContentMetaKey *meta_key, NcmContentInfo **out_content_infos, u32 *out_content_count)
|
|
{
|
|
NcmContentMetaDatabase *ncm_db = NULL;
|
|
|
|
if (!(ncm_db = titleGetNcmDatabaseByStorageId(storage_id)) || !serviceIsActive(&(ncm_db->s)) || !meta_key || !out_content_infos || !out_content_count)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
return false;
|
|
}
|
|
|
|
Result rc = 0;
|
|
|
|
NcmContentMetaHeader content_meta_header = {0};
|
|
u64 content_meta_header_read_size = 0;
|
|
|
|
NcmContentInfo *content_infos = NULL;
|
|
u32 content_count = 0, written = 0;
|
|
|
|
bool success = false;
|
|
|
|
/* Retrieve content meta header. */
|
|
rc = ncmContentMetaDatabaseGet(ncm_db, meta_key, &content_meta_header_read_size, &content_meta_header, sizeof(NcmContentMetaHeader));
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmContentMetaDatabaseGet failed! (0x%08X).", rc);
|
|
goto end;
|
|
}
|
|
|
|
if (content_meta_header_read_size != sizeof(NcmContentMetaHeader))
|
|
{
|
|
LOG_MSG("Content meta header size mismatch! (0x%lX != 0x%lX).", rc, content_meta_header_read_size, sizeof(NcmContentMetaHeader));
|
|
goto end;
|
|
}
|
|
|
|
/* Get content count. */
|
|
content_count = (u32)content_meta_header.content_count;
|
|
if (!content_count)
|
|
{
|
|
LOG_MSG("Content count is zero!");
|
|
goto end;
|
|
}
|
|
|
|
/* Allocate memory for the content infos. */
|
|
content_infos = calloc(content_count, sizeof(NcmContentInfo));
|
|
if (!content_infos)
|
|
{
|
|
LOG_MSG("Unable to allocate memory for the content infos buffer! (%u content[s]).", content_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Retrieve content infos. */
|
|
rc = ncmContentMetaDatabaseListContentInfo(ncm_db, (s32*)&written, content_infos, (s32)content_count, meta_key, 0);
|
|
if (R_FAILED(rc))
|
|
{
|
|
LOG_MSG("ncmContentMetaDatabaseListContentInfo failed! (0x%08X).", rc);
|
|
goto end;
|
|
}
|
|
|
|
if (written != content_count)
|
|
{
|
|
LOG_MSG("Content count mismatch! (%u != %u).", written, content_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Update output. */
|
|
*out_content_infos = content_infos;
|
|
*out_content_count = content_count;
|
|
|
|
success = true;
|
|
|
|
end:
|
|
if (!success && content_infos) free(content_infos);
|
|
|
|
return success;
|
|
}
|
|
|
|
static void titleUpdateTitleInfoLinkedLists(void)
|
|
{
|
|
/* Free orphan title info. */
|
|
titleFreeOrphanTitleInfo();
|
|
|
|
/* Loop through all available user titles. */
|
|
for(u32 i = g_titleInfoBuiltInUserStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
/* Get pointer to the current title info and reset its linked list pointers. */
|
|
TitleInfo *child_info = g_titleInfo[i];
|
|
if (!child_info || child_info->meta_key.type < NcmContentMetaType_Application || child_info->meta_key.type > NcmContentMetaType_AddOnContent) continue;
|
|
|
|
child_info->parent = child_info->previous = child_info->next = NULL;
|
|
|
|
if (child_info->meta_key.type == NcmContentMetaType_Patch || child_info->meta_key.type == NcmContentMetaType_AddOnContent)
|
|
{
|
|
/* We're dealing with a patch or an add-on content. */
|
|
/* Retrieve pointer to the first parent user application entry for patches and add-on contents. */
|
|
/* Since gamecard title info entries are always appended to the end of the buffer, this guarantees we will first retrieve an eMMC / SD card entry (if available). */
|
|
for(u32 j = g_titleInfoBuiltInUserStartIndex; j < g_titleInfoCount; j++)
|
|
{
|
|
TitleInfo *parent_info = g_titleInfo[j];
|
|
if (!parent_info) continue;
|
|
|
|
if (parent_info->meta_key.type == NcmContentMetaType_Application && \
|
|
((child_info->meta_key.type == NcmContentMetaType_Patch && titleCheckIfPatchIdBelongsToApplicationId(parent_info->meta_key.id, child_info->meta_key.id)) || \
|
|
(child_info->meta_key.type == NcmContentMetaType_AddOnContent && titleCheckIfAddOnContentIdBelongsToApplicationId(parent_info->meta_key.id, child_info->meta_key.id))))
|
|
{
|
|
child_info->parent = parent_info;
|
|
if (!child_info->app_metadata) child_info->app_metadata = parent_info->app_metadata;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If we have no application metadata, add orphan title info entry. */
|
|
if (!child_info->app_metadata) titleAddOrphanTitleInfoEntry(child_info);
|
|
}
|
|
|
|
/* Locate previous user application, patch or add-on content entry. */
|
|
/* If it's found, we will update both its next pointer and the previous pointer from the current entry. */
|
|
for(u32 j = i; j > g_titleInfoBuiltInUserStartIndex; j--)
|
|
{
|
|
TitleInfo *previous_info = g_titleInfo[j - 1];
|
|
if (!previous_info) continue;
|
|
|
|
if (previous_info->meta_key.type == child_info->meta_key.type && (((child_info->meta_key.type == NcmContentMetaType_Application || child_info->meta_key.type == NcmContentMetaType_Patch) && \
|
|
previous_info->meta_key.id == child_info->meta_key.id) || (child_info->meta_key.type == NcmContentMetaType_AddOnContent && \
|
|
titleCheckIfAddOnContentIdsAreSiblings(previous_info->meta_key.id, child_info->meta_key.id))))
|
|
{
|
|
previous_info->next = child_info;
|
|
child_info->previous = previous_info;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool titleCreateGameCardInfoThread(void)
|
|
{
|
|
if (!utilsCreateThread(&g_titleGameCardInfoThread, titleGameCardInfoThreadFunc, NULL, 1))
|
|
{
|
|
LOG_MSG("Failed to create gamecard title info thread!");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void titleDestroyGameCardInfoThread(void)
|
|
{
|
|
/* Signal the exit event to terminate the gamecard title info thread. */
|
|
ueventSignal(&g_titleGameCardInfoThreadExitEvent);
|
|
|
|
/* Wait for the gamecard title info thread to exit. */
|
|
utilsJoinThread(&g_titleGameCardInfoThread);
|
|
}
|
|
|
|
static void titleGameCardInfoThreadFunc(void *arg)
|
|
{
|
|
(void)arg;
|
|
|
|
Result rc = 0;
|
|
int idx = 0;
|
|
bool first_run = true;
|
|
|
|
Waiter gamecard_status_event_waiter = waiterForUEvent(g_titleGameCardStatusChangeUserEvent);
|
|
Waiter exit_event_waiter = waiterForUEvent(&g_titleGameCardInfoThreadExitEvent);
|
|
Waiter update_info_waiter = waiterForUEvent(&g_titleGameCardUpdateInfoUserEvent);
|
|
|
|
while(true)
|
|
{
|
|
/* Wait until an event is triggered. */
|
|
rc = waitMulti(&idx, -1, gamecard_status_event_waiter, exit_event_waiter);
|
|
if (R_FAILED(rc)) continue;
|
|
|
|
/* Exit event triggered. */
|
|
if (idx == 1) break;
|
|
|
|
if (!first_run)
|
|
{
|
|
/* Update gamecard info updated flag. */
|
|
mutexLock(&g_titleMutex);
|
|
g_titleGameCardInfoUpdated = true;
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
/* Wait until another function signals us (titleIsGameCardInfoUpdated() or titleExit()). */
|
|
rc = waitMulti(&idx, -1, update_info_waiter, exit_event_waiter);
|
|
if (R_FAILED(rc))
|
|
{
|
|
mutexLock(&g_titleMutex);
|
|
g_titleGameCardInfoUpdated = false;
|
|
mutexUnlock(&g_titleMutex);
|
|
continue;
|
|
}
|
|
|
|
/* Exit event triggered. */
|
|
if (idx == 1) break;
|
|
}
|
|
|
|
/* Update gamecard title info. */
|
|
mutexLock(&g_titleMutex);
|
|
g_titleGameCardInfoUpdated = (titleRefreshGameCardTitleInfo() && !first_run);
|
|
mutexUnlock(&g_titleMutex);
|
|
|
|
if (first_run)
|
|
{
|
|
/* Disable first run flag. */
|
|
first_run = false;
|
|
} else {
|
|
/* Wake up titleIsGameCardInfoUpdated(). */
|
|
condvarWakeAll(&g_gameCardCondVar);
|
|
}
|
|
}
|
|
|
|
/* Update gamecard flags. */
|
|
g_titleGameCardAvailable = g_titleGameCardInfoUpdated = false;
|
|
|
|
threadExit();
|
|
}
|
|
|
|
static bool titleRefreshGameCardTitleInfo(void)
|
|
{
|
|
u32 gamecard_app_count = 0, extra_app_count = 0;
|
|
bool status = false, success = false, cleanup = true, free_entries = false;
|
|
|
|
/* Retrieve current gamecard status. */
|
|
status = (gamecardGetStatus() == GameCardStatus_InsertedAndInfoLoaded);
|
|
if (status == g_titleGameCardAvailable || !status)
|
|
{
|
|
success = cleanup = (status != g_titleGameCardAvailable);
|
|
goto end;
|
|
}
|
|
|
|
/* Open gamecard ncm database and storage handles. */
|
|
if (!titleOpenNcmDatabaseAndStorageFromGameCard())
|
|
{
|
|
LOG_MSG("Failed to open gamecard ncm database and storage handles.");
|
|
goto end;
|
|
}
|
|
|
|
/* Update start index for the gamecard title info entries. */
|
|
g_titleInfoGameCardStartIndex = g_titleInfoCount;
|
|
|
|
/* Generate gamecard title info. */
|
|
if (!titleGenerateTitleInfoFromStorage(NcmStorageId_GameCard))
|
|
{
|
|
LOG_MSG("Failed to generate gamecard title info!");
|
|
goto end;
|
|
}
|
|
|
|
/* Update gamecard title info count. */
|
|
g_titleInfoGameCardCount = (g_titleInfoCount - g_titleInfoGameCardStartIndex);
|
|
if (!g_titleInfoGameCardCount)
|
|
{
|
|
LOG_MSG("Empty content meta key count from gamecard!");
|
|
goto end;
|
|
}
|
|
|
|
/* Get gamecard user application count. */
|
|
for(u32 i = g_titleInfoGameCardStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *cur_title_info = g_titleInfo[i];
|
|
if (cur_title_info && cur_title_info->meta_key.type == NcmContentMetaType_Application) gamecard_app_count++;
|
|
}
|
|
|
|
/* Return immediately if, for some reason, there are no user applications. */
|
|
if (!gamecard_app_count)
|
|
{
|
|
success = true;
|
|
cleanup = false;
|
|
goto end;
|
|
}
|
|
|
|
/* Reallocate application metadata pointer array. */
|
|
if (!titleReallocateApplicationMetadata(gamecard_app_count, false))
|
|
{
|
|
LOG_MSG("Failed to reallocate application metadata pointer array for gamecard user applications!");
|
|
goto end;
|
|
}
|
|
|
|
free_entries = true;
|
|
|
|
/* Retrieve application metadata for gamecard user applications. */
|
|
for(u32 i = g_titleInfoGameCardStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *cur_title_info = g_titleInfo[i];
|
|
if (!cur_title_info) continue;
|
|
|
|
u64 app_id = (cur_title_info->meta_key.type <= NcmContentMetaType_Application ? cur_title_info->meta_key.id : \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_Patch ? titleGetApplicationIdByPatchId(cur_title_info->meta_key.id) : \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_AddOnContent ? titleGetApplicationIdByAddOnContentId(cur_title_info->meta_key.id) : \
|
|
titleGetApplicationIdByDeltaId(cur_title_info->meta_key.id))));
|
|
|
|
/* Do not proceed if application metadata has already been retrieved, or if we can successfully retrieve it. */
|
|
if (cur_title_info->app_metadata != NULL || (cur_title_info->app_metadata = titleFindApplicationMetadataByTitleId(app_id)) != NULL) continue;
|
|
|
|
/* Retrieve application metadata pointer. */
|
|
TitleApplicationMetadata *cur_app_metadata = g_appMetadata[g_appMetadataCount + extra_app_count];
|
|
if (!cur_app_metadata)
|
|
{
|
|
/* Allocate memory for a new application metadata entry. */
|
|
cur_app_metadata = calloc(1, sizeof(TitleApplicationMetadata));
|
|
if (!cur_app_metadata)
|
|
{
|
|
LOG_MSG("Failed to allocate memory for application metadata entry #%u!", extra_app_count);
|
|
goto end;
|
|
}
|
|
|
|
/* Set application metadata entry pointer. */
|
|
g_appMetadata[g_appMetadataCount + extra_app_count] = cur_app_metadata;
|
|
}
|
|
|
|
/* Retrieve application metadata. */
|
|
if (!titleRetrieveApplicationMetadataByTitleId(app_id, cur_app_metadata)) continue;
|
|
|
|
/* Update application metadata pointer in title info. */
|
|
cur_title_info->app_metadata = cur_app_metadata;
|
|
|
|
/* Increase extra application metadata counter. */
|
|
extra_app_count++;
|
|
}
|
|
|
|
if (extra_app_count)
|
|
{
|
|
/* Update application metadata count. */
|
|
g_appMetadataCount += extra_app_count;
|
|
|
|
/* Sort application metadata entries by name. */
|
|
u32 user_app_metadata_count = (g_appMetadataCount - g_systemTitlesCount);
|
|
if (user_app_metadata_count > 1) qsort(g_appMetadata + g_systemTitlesCount, user_app_metadata_count, sizeof(TitleApplicationMetadata*), &titleUserApplicationMetadataEntrySortFunction);
|
|
|
|
/* Update linked lists for user applications, patches and add-on contents. */
|
|
/* This will take care of orphan titles we might now have application metadata for. */
|
|
titleUpdateTitleInfoLinkedLists();
|
|
} else {
|
|
/* Free leftover application metadata entry (if needed). */
|
|
if (g_appMetadata[g_appMetadataCount]) free(g_appMetadata[g_appMetadataCount]);
|
|
}
|
|
|
|
/* Free extra allocated pointers if we didn't use them. */
|
|
if (extra_app_count < gamecard_app_count) titleReallocateApplicationMetadata(0, false);
|
|
|
|
/* Update flags. */
|
|
success = true;
|
|
cleanup = false;
|
|
|
|
end:
|
|
/* Update gamecard status. */
|
|
g_titleGameCardAvailable = status;
|
|
|
|
/* Free previously allocated application metadata pointers. Ignore return value. */
|
|
if (!success && free_entries) titleReallocateApplicationMetadata(extra_app_count, true);
|
|
|
|
/* Remove gamecard title info entries and close its ncm database and storage handles (if needed). */
|
|
if (cleanup)
|
|
{
|
|
titleRemoveGameCardTitleInfoEntries();
|
|
titleCloseNcmDatabaseAndStorageFromGameCard();
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
static void titleRemoveGameCardTitleInfoEntries(void)
|
|
{
|
|
if (!g_titleInfo || !*g_titleInfo || !g_titleInfoCount || !g_titleInfoGameCardCount) return;
|
|
|
|
/* Update title info count. */
|
|
g_titleInfoCount = g_titleInfoGameCardStartIndex;
|
|
|
|
/* Reallocate title info pointer array. */
|
|
titleReallocateTitleInfo(g_titleInfoGameCardCount - 1, true);
|
|
|
|
/* Update gamecard variables. */
|
|
g_titleInfoGameCardStartIndex = g_titleInfoGameCardCount = 0;
|
|
|
|
/* Update linked lists for user applications, patches and add-on contents. */
|
|
/* Won't do anything if g_titleInfoCount is already zero. */
|
|
titleUpdateTitleInfoLinkedLists();
|
|
}
|
|
|
|
static bool titleIsUserApplicationContentAvailable(u64 app_id)
|
|
{
|
|
if (!g_titleInfo || !*g_titleInfo || !g_titleInfoCount || !app_id) return false;
|
|
|
|
for(u32 i = g_titleInfoBuiltInUserStartIndex; i < g_titleInfoCount; i++)
|
|
{
|
|
TitleInfo *cur_title_info = g_titleInfo[i];
|
|
if (!cur_title_info) continue;
|
|
|
|
if ((cur_title_info->meta_key.type == NcmContentMetaType_Application && cur_title_info->meta_key.id == app_id) || \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_Patch && titleCheckIfPatchIdBelongsToApplicationId(app_id, cur_title_info->meta_key.id)) || \
|
|
(cur_title_info->meta_key.type == NcmContentMetaType_AddOnContent && titleCheckIfAddOnContentIdBelongsToApplicationId(app_id, cur_title_info->meta_key.id))) return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static TitleInfo *_titleGetInfoFromStorageByTitleId(u8 storage_id, u64 title_id, bool lock)
|
|
{
|
|
if (lock) mutexLock(&g_titleMutex);
|
|
|
|
TitleInfo *info = NULL;
|
|
|
|
u32 start_idx = ((storage_id == NcmStorageId_BuiltInSystem || storage_id == NcmStorageId_Any) ? 0 : (storage_id == NcmStorageId_BuiltInUser ? g_titleInfoBuiltInUserStartIndex : \
|
|
(storage_id == NcmStorageId_SdCard ? g_titleInfoSdCardStartIndex : g_titleInfoGameCardStartIndex)));
|
|
|
|
u32 max_val = (storage_id == NcmStorageId_BuiltInSystem ? g_titleInfoBuiltInSystemCount : (storage_id == NcmStorageId_BuiltInUser ? g_titleInfoBuiltInUserCount : \
|
|
(storage_id == NcmStorageId_SdCard ? g_titleInfoSdCardCount : (storage_id == NcmStorageId_GameCard ? g_titleInfoGameCardCount : g_titleInfoCount))));
|
|
|
|
max_val += start_idx;
|
|
|
|
if (!g_titleInterfaceInit || !g_titleInfo || !*g_titleInfo || !g_titleInfoCount || storage_id < NcmStorageId_GameCard || storage_id > NcmStorageId_Any || max_val == start_idx || \
|
|
max_val > g_titleInfoCount || start_idx > g_titleInfoCount || !title_id)
|
|
{
|
|
LOG_MSG("Invalid parameters!");
|
|
goto end;
|
|
}
|
|
|
|
for(u32 i = start_idx; i < max_val; i++)
|
|
{
|
|
TitleInfo *title_info = g_titleInfo[i];
|
|
if (title_info && title_info->meta_key.id == title_id)
|
|
{
|
|
info = title_info;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!info && lock) LOG_MSG("Unable to find title info entry with ID \"%016lX\"! (storage ID %u).", title_id, storage_id);
|
|
|
|
end:
|
|
if (lock) mutexUnlock(&g_titleMutex);
|
|
|
|
return info;
|
|
}
|
|
|
|
static int titleSystemTitleMetadataEntrySortFunction(const void *a, const void *b)
|
|
{
|
|
const TitleApplicationMetadata *app_metadata_1 = *((const TitleApplicationMetadata**)a);
|
|
const TitleApplicationMetadata *app_metadata_2 = *((const TitleApplicationMetadata**)b);
|
|
|
|
if (app_metadata_1->title_id < app_metadata_2->title_id)
|
|
{
|
|
return -1;
|
|
} else
|
|
if (app_metadata_1->title_id > app_metadata_2->title_id)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int titleUserApplicationMetadataEntrySortFunction(const void *a, const void *b)
|
|
{
|
|
const TitleApplicationMetadata *app_metadata_1 = *((const TitleApplicationMetadata**)a);
|
|
const TitleApplicationMetadata *app_metadata_2 = *((const TitleApplicationMetadata**)b);
|
|
|
|
return strcasecmp(app_metadata_1->lang_entry.name, app_metadata_2->lang_entry.name);
|
|
}
|
|
|
|
static int titleOrphanTitleInfoSortFunction(const void *a, const void *b)
|
|
{
|
|
const TitleInfo *title_info_1 = *((const TitleInfo**)a);
|
|
const TitleInfo *title_info_2 = *((const TitleInfo**)b);
|
|
|
|
if (title_info_1->meta_key.id < title_info_2->meta_key.id)
|
|
{
|
|
return -1;
|
|
} else
|
|
if (title_info_1->meta_key.id > title_info_2->meta_key.id)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|