ApfelTeeSaft/Itemzflow
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/Itemzflow.git synced 2026-08-26 19:23:39 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
36ca31d21b77c46b8a4c7960b91707c2c570cb49
Itemzflow/itemzflow/source/utils.cpp
T
LightningMods 36ca31d21b ItemzCore version: 1.4-V-2024-01-23T18:42:41 
- Fixed dumping DLCs and AC w/p data
- Added an Install all PKGs option for folders with more than 1 PKG
- Installing a PKG will no longer boot you back to settings
- Carried over some improvements from the PS5 version of IF
- Replaced reg. vectors for ThreadSafeVectors
- Added the Chinese lang files
- Fixed a bug that would cause the Utility thread to deadlock
- Fixed a Bug that caused the daemon not to give a backtrace on 9.00
2024-01-23 18:56:00 -05:00

2331 lines
73 KiB
C++
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#include <md5.h>
#include <errno.h>
#include <sys/time.h>
#include <stdlib.h>
#include <pthread.h>
#include "utils.h"
#include <filesystem>
#include <fstream>
#include <iosfwd>
extern "C"{
#include "mp3/dr_mp3.h"
#include <orbisAudio.h>
#include "ini.h"
#include "log.h"
#include "net.h"
#include "defines.h"
#include "dialog.h"
#include "zip/zip.h"
}
#include <ipc_client.hpp>
#include "installpkg.h"
#include <sys/sysctl.h>
#include <sys/param.h>
#include <sys/mount.h>
#include <signal.h>
#include <atomic>
#include <thread>
#include <string>
#include <vector>
#include <fstream>
/*================== MISC GOLBAL VAR ============*/
static uint32_t sdkVersion = -1;
static std::string checkedsize;
static const char* sizes[] = { "EiB", "PiB", "TiB", "GiB", "MiB", "KiB", "B" };
static const uint64_t exbibytes = 1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL;
void* __stack_chk_guard = (void*)0xdeadbeef;
size_t _orbisFile_lastopenFile_size;
/* =========================================== */
/* ================== IF GLOBAL VARS========== */
ItemzSettings set,
* get;
extern std::string ipc_msg;
extern std::atomic_int inserted_disc;
extern std::atomic_bool is_disc_inserted;
extern struct retry_t* cf_tex;
extern int total_pages;
extern ThreadSafeVector<item_t> all_apps; // Installed_Apps
bool sceAppInst_done = false;
using namespace multi_select_options;
bool (*sceStoreApiLaunchStore)(const char* query) = NULL;
update_ret (*sceStoreApiCheckUpdate)(const char* tid) = NULL;
/* =========================================== */
/* ================== MP3 VARS =====================-*/
#include <libtag/taglib.h>
#include <libtag/fileref.h>
#include <libtag/tag.h>
ThreadSafeVector<item_t> mp3_playlist;
current_song_t current_song;
static uint64_t off2 = 0;
//drmp3_uint8 pData[DRMP3_DATA_CHUNK_SIZE]; // reading buffer from opened file, 16k
static drmp3 mp3; // the main dr_mp3 object
static drmp3_config Config; // and its config
static std::atomic_int dataSize = 0;
static std::vector<uint8_t> mp3data;
extern int g_idx;
static std::atomic_int main_ch = 0;
static std::atomic_int fill = 0;
static std::atomic_bool m_bPlaying = false;
static int numframe = 1;
int retry_mp3_count = 0;
static short play_buf[(1024 * 2) * 4], // small fixed buffer to append decoded pcm s16le samples
snd[1152 * 2]; // small fixed buffer to store a single audio frame of decoded samples
#define MP3_BUFFER_SIZE (1152) // max decoded s16le sample, for a single channel
/*===============================================*/
/*============= USB VARS ========================*/
std::mutex usb_lock;
std::atomic_int usb_number = ATOMIC_VAR_INIT(false);
/*=============================================*/
/*-===================== THEME =========================*/
typedef struct {
std::string name, version, date, author;
bool is_image, has_font, using_sb;
} theme;
const char *required_theme_files[] = {
"theme/btn_o.png", "theme/btn_sq.png",
"theme/btn_tri.png", "theme/btn_x.png",
"theme/btn_up.png", "theme/btn_down.png",
"theme/btn_left.png", "theme/btn_right.png",
"theme/btn_l1.png", "theme/btn_l2.png",
"theme/btn_r1.png"
};
const char *if_d_zip[] = {
"ONLY WORKS IN ITEMZFLOW"
};
bool reboot_app = false;
#include "shaders.h"
double CalcFreeGigs(const char* path) {
struct statfs st;
if (statfs(path, &st) != 0) {
return 0;
}
return (double)st.f_bfree * st.f_bsize / (1024 * 1024 * 1024);
}
#if __cplusplus
extern "C" {
#endif
int64_t sys_dynlib_load_prx(char* prxPath, int* moduleID)
{
return (int64_t)syscall4(594, prxPath, 0, moduleID, 0);
}
int64_t sys_dynlib_unload_prx(int64_t prxID)
{
return (int64_t)syscall1(595, (void*)prxID);
}
int64_t sys_dynlib_dlsym(int64_t moduleHandle, const char* functionName, void* destFuncOffset)
{
return (int64_t)syscall3(591, (void*)moduleHandle, (void*)functionName, destFuncOffset);
}
unsigned char* orbisFileGetFileContent(const char* filename)
{
_orbisFile_lastopenFile_size = -1;
FILE* file = fopen(filename, "rb");
if (!file)
{
log_error("Unable to open file \"%s\".", filename); return NULL;
}
fseek(file, 0, SEEK_END);
size_t size = ftell(file);
fseek(file, 0, SEEK_SET);
unsigned char* buffer = (unsigned char*)malloc((size + 1) * sizeof(char));
fread(buffer, sizeof(char), size, file);
buffer[size] = 0;
_orbisFile_lastopenFile_size = size;
fclose(file);
return buffer;
}
int sceSystemServiceKillApp(uint32_t appid, int opt,int method, int reason);
int sceShellUIUtilInitialize();
int sceShellUIUtilLaunchByUri(const char* uri, SceShellUIUtilLaunchByUriParam *Param);
int sceAppInstUtilAppUnInstallAddcont(const char* title_id, const char* content_id);
int sceAppInstUtilAppUnInstallPat(const char* tid);
int malloc_stats_fast(LibcMallocManagedSize *ManagedSize);
#ifdef __cplusplus
}
#endif
/*=====================================================*/
/*
* Creates all the directories in the provided path. (can include a filename)
* (directory must end with '/')
*/
void* prx_func_loader(std::string prx_path, std::string symbol) {
void* addrp = NULL;
log_info("Loading %s", prx_path.c_str());
int libcmi = sceKernelLoadStartModule(prx_path.c_str(), 0, nullptr, 0, 0, 0);
if(libcmi < 0){
log_error("Error loading prx: 0x%X", libcmi);
return addrp;
}
else
log_debug("%s loaded successfully", prx_path.c_str());
if(sceKernelDlsym(libcmi, symbol.c_str(), &addrp) < 0){
log_error("Symbol %s NOT Found", symbol.c_str());
}
else
log_debug("Function %s | addr %p loaded successfully", symbol.c_str(), addrp);
return addrp;
}
// folder that sees if a path is a folder
bool is_folder(const char* path)
{
struct stat st;
if (stat(path, &st) == 0)
return S_ISDIR(st.st_mode);
return false;
}
static int theme_info(void* user, const char* section, const char* name,
const char* value, int unused)
{
static char prev_section[50] = "";
if (strcmp("THEME", prev_section)) {
log_debug("%s [%s]", (prev_section[0] ? "" : ""), section);
strncpy(prev_section, section, sizeof(prev_section));
prev_section[sizeof(prev_section) - 1] = '\0';
}
theme* set = (theme*)user;
#define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0
if (MATCH("THEME", "Author")) {
set->author = value;
}
if (MATCH("THEME", "Date")) {
set->date = value;
}
if (MATCH("THEME", "Name")) {
set->name = value;
}
if (MATCH("THEME", "Version")) {
set->version = value;
}
if (MATCH("THEME", "Image")) {
set->is_image = atol(value);
}
if (MATCH("THEME", "Font")) {
set->has_font = atol(value);
}
if (MATCH("THEME", "Shader") && !set->is_image) {
set->using_sb = atol(value);
}
return 0;
}
void __stack_chk_fail(void)
{
log_info("Stack smashing detected.");
msgok(MSG_DIALOG::FATAL, "Stack Smashing has been Detected");
}
bool IS_ERROR(uint32_t ret)
{
return ret & 0x80000000;
}
std::string calculateSize(uint64_t size)
{
std::string result;
uint64_t multiplier = exbibytes;
int i;
for (i = 0; i < DIM(sizes); i++, multiplier /= 1024)
{
if (size < multiplier)
continue;
if (size % multiplier == 0)
result = fmt::format("{0:} {1:}", size / multiplier, sizes[i]);
else
result = fmt::format("{0:.1f} {1:}", (float)(size / multiplier), sizes[i]);
return result;
}
result = "0";
return result;
}
size_t CalcAppsize(const char* filename) {
struct stat st;
if(stat(filename, &st) != 0) {
return 0;
}
return st.st_size;
}
int ItemzLocalKillApp(uint32_t appid) {
log_info("ItemzLocalKillApp(%x, -1, 0, 0)", appid);
if ((appid & ~0xFFFFFF) == 0x60000000)
return sceSystemServiceKillApp(appid, -1, 0, 0);
else
return ITEMZCORE_EINVAL;
}
int ItemzLaunchByUri(const char* uri) {
int libcmi = -1;
if (!uri)
return ITEMZCORE_EINVAL;
if (sys_dynlib_load_prx((char*)"/system/common/lib/libSceShellUIUtil.sprx", &libcmi) < 0 || libcmi < 0)
return ITEMZCORE_PRX_RESOLVE_ERROR;
SceShellUIUtilLaunchByUriParam Param;
Param.size = sizeof(SceShellUIUtilLaunchByUriParam);
sceUserServiceGetForegroundUser(&Param.userId); // DONT CARE
log_info("ItemzLaunchByUri(%s)", uri);
log_info("sceShellUIUtilInitialize returned %x", sceShellUIUtilInitialize());
return sceShellUIUtilLaunchByUri(uri, &Param);
}
bool copyFile(std::string source, std::string dest, bool show_progress)
{
std::string buf;
int src = sceKernelOpen(source.c_str(), 0x0000, 0);
if (src > 0)
{
int out = sceKernelOpen(dest.c_str(), 0x0001 | 0x0200 | 0x0400, 0777);
if (out > 0)
{
if(show_progress)
progstart("Starting...");
size_t bytes ,total = 0;
size_t len = CalcAppsize(source.c_str());
std::string size = calculateSize(len);
std::vector<char> buffer(MB(10));
if (buffer.size() > 0)
{
while (0 < (bytes = sceKernelRead(src, &buffer[0], MB(10)))){
sceKernelWrite(out, &buffer[0], bytes);
total += bytes;
if(show_progress){
uint32_t g_progress = (uint32_t)(((float)total / len) * 100.f);
int status = sceMsgDialogUpdateStatus();
if (ORBIS_COMMON_DIALOG_STATUS_RUNNING == status) {
buf = fmt::format("{0:}...\n Size: {1:}", getLangSTR(LANG_STR::COPYING_FILE), size);
sceMsgDialogProgressBarSetValue(0, g_progress);
sceMsgDialogProgressBarSetMsg(0, buf.c_str());
}
}
}
buffer.clear();
}
}
else
{
fmt::print("Could copy file: {} Reason: {x}", src, out);
sceKernelClose(src);
if(show_progress)
sceMsgDialogTerminate();
return false;
}
sceKernelClose(src);
sceKernelClose(out);
sceMsgDialogTerminate();
return true;
}
else
{
fmt::print("Could copy file: {} Reason: {x}", dest, src);
return false;
}
}
void ProgSetMessagewText(int prog, const char* fmt, ...)
{
char buff[300];
memset(&buff[0], 0, sizeof(buff));
va_list args;
va_start(args, fmt);
vsnprintf(&buff[0], 299, fmt, args);
va_end(args);
sceMsgDialogProgressBarSetValue(0, prog);
sceMsgDialogProgressBarSetMsg(0, buff);
}
/// timing
float get_time_ms(std::chrono::time_point<std::chrono::system_clock> &last_time)
{
auto now = std::chrono::system_clock::now();
auto duration = now - last_time;
auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
last_time = now;
return (float)(millis / 1000.f);
}
bool touch_file(const char* destfile)
{
int fd = open(destfile, O_WRONLY | O_CREAT | O_TRUNC, 0777);
if (fd > 0) {
unlink(destfile);
close(fd);
return true;
}
else
return false;
}
#define SCE_KERNEL_EVF_WAITMODE_OR 0x02
unsigned char _bittest64(uint64_t *Base, uint64_t Offset)
{
int old = 0;
__asm__ __volatile__("btq %2,%1\n\tsbbl %0,%0 "
:"=r" (old),"=m" ((*(volatile long long *) Base))
:"Ir" (Offset));
return (old != 0);
}
// both real and _func functions are the same
unsigned int sceShellCoreUtilIsUsbMassStorageMounted(unsigned int usb_index);
//interchangable
unsigned int sceShellCoreUtilIsUsbMassStorageMounted_func(unsigned int usb_index)
{
uint64_t res;
void* ef;
if ( (unsigned int)sceKernelOpenEventFlag(&ef, "SceAutoMountUsbMass") )
return 0;
sceKernelPollEventFlag(ef, 0xFFFFFFF, SCE_KERNEL_EVF_WAITMODE_OR, &res);
sceKernelCloseEventFlag(ef);
return _bittest64(&res, usb_index);
}
unsigned int usbpath()
{
// std::lock_guard<std::mutex> lock(disc_lock);
unsigned int usb_index = -1;
for (int i = 0; i < 8; i++){
if (sceShellCoreUtilIsUsbMassStorageMounted_func((unsigned int)i)){
usb_index = i;
//log_info("[UTIL] USB %i is mounted, SceAutoMountUsbMass: %i", i, usb_number);
break;
}
}
return usb_index;
}
bool MD5_file_compare(const char* file1, const char* file2)
{
unsigned char c[MD5_HASH_LENGTH];
unsigned char c2[MD5_HASH_LENGTH];
int i;
FILE* f1 = fopen(file1, "rb");
FILE* f2 = fopen(file2, "rb");
if(!f1)
{
log_error("Could not open both files");
return false;
}
if(!f2)
{
fclose(f1);
log_error("Could not open both files");
return false;
}
MD5_CTX mdContext;
MD5_CTX mdContext2;
int bytes2 = 0;
unsigned char data2[1024];
int bytes = 0;
unsigned char data[1024];
MD5_Init(&mdContext);
while ((bytes = fread(data, 1, 1024, f1)) != 0)
MD5_Update(&mdContext, data, bytes);
MD5_Final(c, &mdContext);
MD5_Init(&mdContext2);
while ((bytes2 = fread(data2, 1, 1024, f2)) != 0)
MD5_Update(&mdContext2, data2, bytes2);
MD5_Final(c2, &mdContext2);
for (i = 0; i < 16; i++)
{
if (c[i] != c2[i]){
log_error("MD5 compare failed: %s != %s HASH %s | %s", file1, file2, c, c2);
fclose(f1);
fclose(f2);
return false;
}
}
fclose(f1);
fclose(f2);
log_info("MD5s match for %s and %s", file1, file2);
return true;
}
bool MD5_hash_compare(const char* file1, const char* hash)
{
unsigned char c[MD5_HASH_LENGTH];
FILE* f1 = fopen(file1, "rb");
if(!f1) return false;
MD5_CTX mdContext;
int bytes = 0;
unsigned char data[1024];
MD5_Init(&mdContext);
while ((bytes = fread(data, 1, 1024, f1)) != 0)
MD5_Update(&mdContext, data, bytes);
MD5_Final(c, &mdContext);
char md5_string[33] = {0};
for(int i = 0; i < 16; ++i) {
snprintf(&md5_string[i*2], 32, "%02x", (unsigned int)c[i]);
}
log_info( "[MD5] FILE HASH: %s", md5_string);
md5_string[32] = 0;
if (strcmp(md5_string, hash) != 0) {
fclose(f1);
return DIFFERENT_HASH;
}
log_info( "[MD5] Input HASH: %s", hash);
fclose(f1);
return SAME_HASH;
}
bool is_apputil_init()
{
int ret = sceAppInstUtilInitialize();
if (ret) {
log_error( " sceAppInstUtilInitialize failed: 0x%08X", ret);
return false;
}
else
sceAppInst_done = true;
return true;
}
bool app_inst_util_uninstall_patch(const char* title_id, int* error) {
int ret;
*error = 0;
if(!sceAppInst_done)
{
bool res = is_apputil_init();
if (!res)
{ *error = 0xDEADBEEF;
return false;
}
}
if (!title_id) {
ret = 0x80020016;
if (error) {
*error = ret;
}
goto err;
}
ret = sceAppInstUtilAppUnInstallPat(title_id);
if (ret)
{
if (error) {
*error = ret;
}
log_error( " sceAppInstUtilAppUnInstallPat failed: 0x%08X", ret);
goto err;
}
return true;
err:
log_error("app_inst_util_uninstall_patch: 0x%X", error);
return false;
}
bool app_inst_util_uninstall_game(const char *title_id, int *error)
{
int ret;
*error = 0;
if (strlen(title_id) != 9)
{
*error = 0xBADBAD;
return false;
}
if(!sceAppInst_done)
{
bool res = is_apputil_init();
if (!res)
{ *error = 0xDEADBEEF;
return false;
}
}
if (!title_id)
{
ret = 0x80020016;
if (error)
{
*error = ret;
}
goto err;
}
ret = sceAppInstUtilAppUnInstall(title_id);
if (ret)
{
if (error)
{
*error = ret;
}
log_error( " sceAppInstUtilAppUnInstall failed: 0x%08X", ret);
goto err;
}
return true;
err:
log_error("app_inst_util_uninstall_game: 0x%X", error);
return false;
}
bool app_inst_util_uninstall_ac(const char* content_id, const char* title_id, int* error) {
*error = 0;
if (!sceAppInst_done)
{
bool res = is_apputil_init();
if (!res)
{
*error = 0xDEADBEEF;
return false;
}
}
int ret = sceAppInstUtilAppUnInstallAddcont(title_id, content_id);
if (ret) {
if (error) {
*error = ret;
}
log_error("sceAppInstUtilAppUnInstallAddcont failed: 0x%08X", ret);
return false;
}
return true;
}
int app_inst_util_get_size(const char* title_id) {
uint64_t size = 0;
if (!sceAppInst_done) {
log_debug(" Starting app_inst_util_init..");
if (!app_inst_util_init()) {
log_error("app_inst_util_init has failed...");
return ITEMZCORE_GENERAL_ERROR;
}
}
int ret = sceAppInstUtilAppGetSize(title_id, &size);
if (ret) {
log_error("sceAppInstUtilAppGetSize failed: 0x%08X", ret);
return ret;
}
else
log_info("Size: %s", calculateSize(size).c_str());
return B2GB(size);
}
bool Fnt_setting_enabled = false;
static int print_ini_info(void* user, const char* section, const char* name,
const char* value, int unused)
{
static char prev_section[50] = "";
if (strcmp(section, prev_section)) {
log_debug("%s[%s]", (prev_section[0] ? "" : ""), section);
strncpy(prev_section, section, sizeof(prev_section));
prev_section[sizeof(prev_section) - 1] = '\0';
}
ItemzSettings* set = (ItemzSettings*)user;
#define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0
//log_info("Settings: %s = %s", name, value);
if (MATCH("Settings", "Daemon_on_start")) {
set->setting_bools[Daemon_on_start] = atoi(value);
}
else if (MATCH("Settings", "TTF_Font")) {
set->setting_strings[FNT_PATH] = value;
if (set->setting_strings[FNT_PATH].find("SCE-PS3-RD-R-LATIN.TTF") == std::string::npos){
log_debug("Font is not default, enabling font settings");
Fnt_setting_enabled = true;
}
}
else if (MATCH("Settings", "HomeMenu_Redirection")) {
set->setting_bools[HomeMenu_Redirection] = atoi(value);
}
else if (MATCH("Settings", "Show_install_prog")) {
set->setting_bools[Show_install_prog] = atoi(value);
}
else if (MATCH("Settings", "Dumper_option")) {
set->Dump_opt = (Dump_Multi_Sels)atoi(value);
}
else if (MATCH("Settings", "Sort_By")) {
set->sort_by = (Sort_Multi_Sel)atoi(value);
}
else if (MATCH("Settings", "Sort_Cat")) {
set->sort_cat = (Sort_Category)atoi(value);
}
else if (MATCH("Settings", "cover_message")) {
set->setting_bools[cover_message] = atoi(value);
}
else if (MATCH("Settings", "Dumper_Path")) {
set->setting_strings[DUMPER_PATH] = value;
}
else if (MATCH("Settings", "MP3_Path")) {
set->setting_strings[MP3_PATH] = value;
}
else if (MATCH("Settings", "Show_Buttons")) {
set->setting_bools[Show_Buttons] = atoi(value);
}
else if (MATCH("Settings", "Enable_Theme")) {
set->setting_bools[using_theme] = atoi(value);
log_debug("Enable_Theme: %d : %d", set->setting_bools[using_theme], atoi(value));
}
else if (MATCH("Settings", "Image_path")) {
set->setting_strings[IMAGE_PATH] = value;//nReflections
}
else if (MATCH("Settings", "Reflections")) {
use_reflection = atoi(value);
}
else if (MATCH("Settings", "Fuse_IP")) {
set->setting_strings[FUSE_PC_NFS_IP] = value;
}
else if(MATCH("Settings", "Internal_update")){
set->setting_bools[INTERNAL_UPDATE] = atoi(value);
}
return 1;
}
bool LoadOptions(ItemzSettings *set)
{
bool no_error = true;
int error = 1;
theme t;
unsigned int usb_num = usbpath();
set->setting_bools.reserve(NUMB_OF_BOOLS);
set->setting_strings.reserve(NUMB_OF_STRINGS);
//"http://IFUpdate.pkg-zone.com"
dump = SEL_RESET;
set->setting_bools[Daemon_on_start] = true;
set->Dump_opt = SEL_DUMP_ALL;
set->sort_cat = NO_CATEGORY_FILTER;
set->sort_by = multi_select_options::NA_SORT;
set->setting_bools[using_sb] = true;
set->setting_bools[INTERNAL_UPDATE] = false;
set->setting_bools[Show_install_prog] = true;
set->setting_bools[Show_Buttons] = true;
set->setting_bools[HomeMenu_Redirection] = false;
set->setting_bools[cover_message] = true;
set->setting_strings[THEME_NAME] = "Default Theme";
set->setting_strings[THEME_AUTHOR] = "LM & MZ";
set->setting_strings[THEME_VERSION] = "1.00";
set->ItemzCore_AppId = sceSystemServiceGetAppIdOfMiniApp();
set->ItemzDaemon_AppId = -1;
if(usb_num != -1)
set->setting_strings[DUMPER_PATH] = fmt::format("/mnt/usb{}/", usb_num);
else
set->setting_strings[DUMPER_PATH] = "/mnt/usb0";
set->setting_strings[FNT_PATH] = "/system_ex/app/NPXS20113/bdjstack/lib/fonts/SCE-PS3-RD-R-LATIN.TTF";
/* Initialize INI structure */
if (usb_num != -1)
{
set->setting_strings[INI_PATH] = fmt::format("{}/settings.ini", set->setting_strings[DUMPER_PATH]);
if (!if_exists(set->setting_strings[INI_PATH].c_str()))
{
log_warn("No INI on USB");
if (if_exists("/user/app/ITEM00001/settings.ini")){
set->setting_strings[INI_PATH] = "/user/app/ITEM00001/settings.ini";
error = ini_parse("/user/app/ITEM00001/settings.ini", print_ini_info, set);
if (error < 0) log_error("Bad config file (first error on line %d)!", error);
}
} else {
error = ini_parse(set->setting_strings[INI_PATH].c_str(), print_ini_info, set);
if (error < 0) log_error("Bad config file (first error on line %d)!", error);
log_info( " Loading ini from USB");
}
}
else if (!if_exists("/user/app/ITEM00001/settings.ini"))
{
log_error("CANT FIND INI"); no_error = false;
} else {
error = ini_parse("/user/app/ITEM00001/settings.ini", print_ini_info, set);
if (error < 0) log_error("Bad config file (first error on line %d)!", error);
log_info( " Loading ini from APP DIR");
set->setting_strings[INI_PATH] = "/user/app/ITEM00001/settings.ini";
}
if(set->setting_bools[using_theme] && (set->setting_bools[using_theme] = if_exists(APP_PATH("theme/theme.ini")))){
log_debug("[THEME] Using Theme detected");
log_debug("[THEME] Getting Theme Info");
t.is_image = false;
t.using_sb = false;
t.has_font = false;
if(ini_parse(APP_PATH("theme/theme.ini"), theme_info, &t) < 0){
log_error("[THEME] Failed to get Theme Info");
set->setting_bools[using_theme] = false;
goto no_theme;
}
log_debug("[THEME] ======== Theme Info =======");
fmt::print("[THEME] Name: {}", t.name);
fmt::print("[THEME] Version: {}", t.version);
fmt::print("[THEME] Author: {}", t.author);
fmt::print("[THEME] Date: {}", t.date);
set->setting_strings[THEME_NAME] = t.name;
set->setting_strings[THEME_VERSION] = t.version;
set->setting_strings[THEME_AUTHOR] = t.author;
log_debug("[THEME] Image: %s", t.is_image ? "Yes" : "No");
log_debug("[THEME] Font: %s", t.has_font ? "Yes" : "No");
log_debug("[THEME] Shader: %s", t.using_sb ? "Yes" : "No");
log_debug("[THEME] ======== End of Theme Info =======");
log_debug("[THEME] Setting ItemzCore settings ...");
if(t.has_font){
//THEME FONT CHECK
set->setting_strings[FNT_PATH] = fmt::format("{}/font.ttf", APP_PATH("theme"));
if(!if_exists(set->setting_strings[FNT_PATH].c_str())){
log_error("[THEME] Font not found");
t.has_font = false;
}
else{
log_debug("[THEME] Font found");
Fnt_setting_enabled = true;
}
}
else
log_debug("[THEME] No Font being used");
if(t.is_image){
set->setting_strings[IMAGE_PATH] = fmt::format("{}/background.png", APP_PATH("theme"));
if(!if_exists( set->setting_strings[IMAGE_PATH].c_str())){
fmt::print("[THEME] Image not found, looked @ {}", set->setting_strings[IMAGE_PATH]);
set->setting_bools[has_image] = t.is_image = false;
}
else{
fmt::print("[THEME] Image found @ {}", set->setting_strings[IMAGE_PATH]);
set->setting_bools[has_image] = true;
set->setting_bools[using_sb] = false;
}
}
else {
log_debug("[THEME] No Image being used");
set->setting_strings[SB_PATH] = fmt::format("{}/shader.bin", APP_PATH("theme"));
if(!if_exists(set->setting_strings[SB_PATH].c_str())){
log_error("[THEME] Shader not found");
set->setting_bools[using_sb] = t.using_sb = false;
}
else{
log_debug("[THEME] Shader found");
set->setting_bools[using_sb] = true;
set->setting_bools[has_image] = false;
}
}
log_debug("[THEME] Freeing Theme ...");
}
no_theme:
if(!set->setting_strings[IMAGE_PATH].empty()
&& !set->setting_bools[has_image]){
set->setting_bools[has_image] = true;
set->setting_bools[using_sb] = false;
}
log_debug("Starting Lang.");
uint32_t lang = PS4GetLang();
if (error < 0)
log_error("ERROR reading INI setting default vals");
#if TEST_INI_LANGS
for (int i = 0; i < 29; i++)
{
if (!LoadLangs(i))
log_debug("Failed to Load %s", Language_GetName(i));
else
log_debug("Successfully Loaded %s", Language_GetName(i));
}
#endif
//fallback lang
#ifdef OVERRIDE_LANG
lang = OVERRIDE_LANG;
#else
set->lang = lang;
#endif
if (!LoadLangs(lang)) {
set->lang = 0x01; /// fallback english
if (!LoadLangs(set->lang)) {
log_debug(" This PKG has no lang files... trying embedded");
if(!load_embdded_eng())
msgok(MSG_DIALOG::FATAL, "Failed to load Backup Lang...\nThe App is unable to continue");
else
log_debug(" Loaded embdded ini lang file");
}
else
log_debug(" Loaded the backup, %s failed to load", Language_GetName(lang).c_str());
}
if (!Fnt_setting_enabled) {
switch (lang) {
case 0: //jAPN IS GREAT
set->setting_strings[FNT_PATH] = asset_path("fonts/NotoSansJP-Regular.ttf");
break;
case 9:///THIS IS FOR JOON, IF HE COMES BACK
set->setting_strings[FNT_PATH] = asset_path("fonts/NotoSansKR-Regular.ttf");
break;
case 21:
case 23:
case 24:
case 25:
case 26:
set->setting_strings[FNT_PATH] = asset_path("fonts/HelveticaWorld-Multi.ttf");
break;
//NO USERS HAS TRANSLATED THE FOLLOWING LANGS, SO I DELETED THEM OUT THE PKG TO SAVE SPACE
/*
case 10:
strcpy(set->opt[FNT_PATH],"/mnt/sandbox/pfsmnt/ITEM00001-app0/assets/fonts/NotoSansTC-Regular.ttf");
break;
case 11:
strcpy(set->opt[FNT_PATH],"/mnt/sandbox/pfsmnt/ITEM00001-app0/assets/fonts/NotoSansSC-Regular.ttf");
break;
case 27:
strcpy(set->opt[FNT_PATH],"/mnt/sandbox/pfsmnt/ITEM00001-app0/assets/fonts/NotoSansThai-Regular.ttf");
break;*/
default:
break;
}
}
//
fmt::print("set->ini_path: {}", set->setting_strings[INI_PATH]);
fmt::print("set->dumper_path: {}", set->setting_strings[DUMPER_PATH]);
fmt::print("get->fnt_path: {}", set->setting_strings[FNT_PATH]);
fmt::print("set->fuse_ip: {}", set->setting_strings[FUSE_PC_NFS_IP]);
fmt::print("set->RESTRICTED: {}", set->setting_bools[INTERNAL_UPDATE]);
log_info( "set->Daemon_... : %s", set->setting_bools[Daemon_on_start] ? "ON" : "OFF");
log_info( "set->HomeMen... : %s", set->setting_bools[HomeMenu_Redirection] ? "ItemzFlow (ON)" : "Orbis (OFF)");
log_info( "set->sort_by : %i", set->sort_by);
log_info( "set->Cover_message : %i", set->setting_bools[Cover_message]);
log_info( "set->using_theme : %i", set->setting_bools[using_theme]);
log_info( "set->Dump_opt : %i", set->Dump_opt);
log_info( "set->Install_prog.: %s", set->setting_bools[Show_install_prog] ? "ON" : "OFF");
log_info( "set->Lang : %s : %i", Language_GetName(lang).c_str(), set->lang);
return no_error;
}
bool SaveOptions(ItemzSettings *set)
{
std::string ini_content = fmt::format("[Settings]\nSort_By={0:d}\nSort_Cat={1:d}\nSecure_Boot=1\nTTF_Font={2:}\nShow_install_prog={3:d}\nHomeMenu_Redirection={4:d}\nDaemon_on_start={5:d}\ncover_message={6:d}\nDumper_Path={7:}\nMP3_Path={8:}\nShow_Buttons={9:d}\nEnable_Theme={10:d}\nImage_path={11:}\nReflections={12:d}\nFuse_IP={13:}\n{14:}={15:d}", (int)set->sort_by, (int)set->sort_cat, set->setting_strings[FNT_PATH], set->setting_bools[Show_install_prog], set->setting_bools[HomeMenu_Redirection], set->setting_bools[Daemon_on_start], set->setting_bools[cover_message], set->setting_strings[DUMPER_PATH], set->setting_strings[MP3_PATH], set->setting_bools[Show_Buttons], set->setting_bools[using_theme], set->setting_strings[IMAGE_PATH], use_reflection, set->setting_strings[FUSE_PC_NFS_IP], set->setting_bools[INTERNAL_UPDATE] ? "Internal_update" : "RESTRICTED" , set->setting_bools[INTERNAL_UPDATE]);
std::ofstream out(set->setting_strings[INI_PATH]);
if(out.bad()){
log_error("Failed to create ini file");
return false;
}
out << ini_content;
out.close();
log_info("============ Saving the following settings ============");
fmt::print("set->ini_path: {}", set->setting_strings[INI_PATH]);
fmt::print("set->dumper_path: {}", set->setting_strings[DUMPER_PATH]);
fmt::print("get->fnt_path: {}", set->setting_strings[FNT_PATH]);
fmt::print("set->mp3_path: {}", set->setting_strings[MP3_PATH]);
fmt::print("set->fuse_ip: {}", set->setting_strings[FUSE_PC_NFS_IP]);
log_info("set->Daemon_... : %s", set->setting_bools[Daemon_on_start] ? "ON" : "OFF");
log_info("set->HomeMen... : %s", set->setting_bools[HomeMenu_Redirection] ? "ItemzFlow (ON)" : "Orbis (OFF)");
log_info("set->sort_by : %i", set->sort_by);
log_info("set->Show_Buttons : %i", set->setting_bools[Show_Buttons]);
log_info("set->cover_message : %i", set->setting_bools[cover_message]);
log_info("set->Dump_opt : %i", set->Dump_opt);
log_info("set->using_theme : %i", set->setting_bools[using_theme]);
log_info("set->RESTIRCTED : %i", set->setting_bools[INTERNAL_UPDATE]);
log_info("set->Install_prog.: %s", set->setting_bools[Show_install_prog] ? "ON" : "OFF");
log_info("set->Lang : %s : %i", Language_GetName(set->lang).c_str(), set->lang);
log_info("==========================================================");
/* Load values */
chmod(set->setting_strings[INI_PATH].c_str(), 0777);
return true;
}
uint32_t ps4_fw_version(void)
{
//cache the FW Version
if (0 < sdkVersion) {
size_t len = 4;
// sysKernelGetLowerLimitUpdVersion == machdep.lower_limit_upd_version
// rewrite of sysKernelGetLowerLimitUpdVersion
sysctlbyname("machdep.lower_limit_upd_version", &sdkVersion, &len, NULL, 0);
}
// FW Returned is in HEX
return sdkVersion;
}
//////////////////////////////////////////////////////
bool Keyboard(const char* Title, const char* initialTextBuffer, char* out_buffer, bool keypad)
{
sceSysmoduleLoadModule(ORBIS_SYSMODULE_IME_DIALOG);
wchar_t title[100];
wchar_t inputTextBuffer[255];
char titl[100];
if (initialTextBuffer
&& strlen(initialTextBuffer) > 1023) return "Too Long";
memset(&inputTextBuffer[0], 0, 255);
memset(out_buffer, 0, 255);
if (initialTextBuffer)
snprintf(out_buffer, 254, "%s", initialTextBuffer);
//converts the multibyte string src to a wide-character string starting at dest.
mbstowcs(&inputTextBuffer[0], out_buffer, strlen(out_buffer) + 1);
// use custom title
snprintf(&titl[0], 99, "%s", Title ? Title : "Itemzflow");
//converts the multibyte string src to a wide-character string starting at dest.
mbstowcs(title, titl, strlen(titl) + 1);
OrbisImeDialogParam param;
memset(&param, 0, sizeof(OrbisImeDialogParam));
param.maxTextLength = 1023;
param.inputTextBuffer = inputTextBuffer;
param.title = title;
param.userId = 0xFE;
param.type = ORBIS_IME_TYPE_BASIC_LATIN;
if (keypad)
param.type = ORBIS_IME_TYPE_NUMBER;
param.enterLabel = ORBIS_IME_ENTER_LABEL_DEFAULT;
sceImeDialogInit(&param, NULL);
int status;
while (1)
{
status = sceImeDialogGetStatus();
if (status == ORBIS_IME_DIALOG_STATUS_FINISHED)
{
OrbisImeDialogResult result;
memset(&result, 0, sizeof(OrbisImeDialogResult));
sceImeDialogGetResult(&result);
log_info("status %i, endstatus %i ", status, result.endstatus);
if (result.endstatus == ORBIS_IME_DIALOG_END_STATUS_USER_CANCELED){
log_info("User Cancelled this Keyboard Session");
ani_notify(NOTIFI::WARNING, getLangSTR(LANG_STR::OP_CANNED), getLangSTR(LANG_STR::OP_CANNED_1));
}
else if (result.endstatus == ORBIS_IME_DIALOG_END_STATUS_OK)
{
log_info("User Entered text.. Entering into buffer");
wcstombs(out_buffer, &inputTextBuffer[0], 254);
sceImeDialogTerm();
return true;
}
goto Finished;
}
else if (status == ORBIS_IME_DIALOG_STATUS_NONE) goto Finished;
}
Finished:
sceImeDialogTerm();
return false;
}
bool rmtree(const char path[]) {
struct dirent* de;
char fname[300];
DIR* dr = opendir(path);
if (dr == NULL)
{
log_debug("No file or directory found: %s", path);
return false;
}
while ((de = readdir(dr)) != NULL)
{
int ret = -1;
struct stat statbuf;
snprintf(fname, 299, "%s/%s", path, de->d_name);
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (!stat(fname, &statbuf))
{
if (S_ISDIR(statbuf.st_mode))
{
log_debug("removing dir: %s Err: %d", fname, ret = unlinkat(dirfd(dr), fname, AT_REMOVEDIR));
if (ret != 0)
{
rmtree(fname);
log_debug("Err: %d", ret = unlinkat(dirfd(dr), fname, AT_REMOVEDIR));
}
}
else
{
log_debug("Removing file: %s, Err: %d", fname, unlink(fname));
}
}
}
closedir(dr);
return true;
}
void print_memory()
{
size_t sz = 0;
LibcMallocManagedSize ManagedSize;
SCE_LIBC_INIT_MALLOC_MANAGED_SIZE(ManagedSize);
malloc_stats_fast(&ManagedSize);
sceKernelAvailableFlexibleMemorySize(&sz);
double dfp_fmem = (1. - (double)sz / (double)0x8000000) * 100.;
log_info("[MEM] CurrentSystemSize: %s, CurrentInUseSize: %s", calculateSize(ManagedSize.currentSystemSize).c_str(), calculateSize(ManagedSize.currentInuseSize).c_str());
log_info("[MEM] MaxSystemSize: %s, MaxInUseSize: %s", calculateSize(ManagedSize.maxSystemSize).c_str(), calculateSize(ManagedSize.maxInuseSize).c_str());
log_info("[VRAM] VRAM_Available: %s, AmountUsed: %.2f%%",calculateSize(sz).c_str(), dfp_fmem);
}
void Kill_BigApp(std::atomic<GameStatus> &status){
int ret = -1;
int BigAppid = sceSystemServiceGetAppIdOfBigApp();
if(status == NO_APP_OPENED || status == APP_NA_STATUS)
{
log_info("[CLOSE] No App is opened");
return;
}
log_info("[CLOSE] BigApp ID: 0x%X", BigAppid);
if ((ret = ItemzLocalKillApp(BigAppid)) == ITEMZCORE_SUCCESS)
{
ani_notify(NOTIFI::INFO, getLangSTR(LANG_STR::APP_CLOSED), "");
log_info("[CLOSE] App Closed");
}
else
{
ani_notify(NOTIFI::WARNING, getLangSTR(LANG_STR::FAILED_TO_CLOSE), fmt::format( "{0:}: {1:#x}", getLangSTR(LANG_STR::ERROR_CODE), ret));
log_error("[CLOSE] Failed to close APP: 0x%X", ret);
}
status = NO_APP_OPENED;
}
int progstart(const char* format, ...)
{
int ret = 0;
char buff[1024];
memset(buff, 0, 1024);
va_list args;
va_start(args, format);
vsprintf(&buff[0], format, args);
va_end(args);
sceSysmoduleLoadModule(ORBIS_SYSMODULE_MESSAGE_DIALOG);
sceMsgDialogInitialize();
OrbisMsgDialogParam dialogParam;
OrbisMsgDialogParamInitialize(&dialogParam);
dialogParam.mode = ORBIS_MSG_DIALOG_MODE_PROGRESS_BAR;
OrbisMsgDialogProgressBarParam progBarParam;
memset(&progBarParam, 0, sizeof(OrbisMsgDialogProgressBarParam));
dialogParam.progBarParam = &progBarParam;
dialogParam.progBarParam->barType = ORBIS_MSG_DIALOG_PROGRESSBAR_TYPE_PERCENTAGE;
dialogParam.progBarParam->msg = &buff[0];
sceMsgDialogOpen(&dialogParam);
return ret;
}
int Confirmation_Msg(std::string msg)
{
sceMsgDialogTerminate();
//ds
sceMsgDialogInitialize();
OrbisMsgDialogParam param;
OrbisMsgDialogParamInitialize(&param);
param.mode = ORBIS_MSG_DIALOG_MODE_USER_MSG;
OrbisMsgDialogUserMessageParam userMsgParam;
memset(&userMsgParam, 0, sizeof(userMsgParam));
userMsgParam.msg = msg.c_str();
userMsgParam.buttonType = ORBIS_MSG_DIALOG_BUTTON_TYPE_YESNO;
param.userMsgParam = &userMsgParam;
// cv
if (0 < sceMsgDialogOpen(&param))
return NO;
OrbisCommonDialogStatus stat;
//
while (1) {
stat = sceMsgDialogUpdateStatus();
if (stat == ORBIS_COMMON_DIALOG_STATUS_FINISHED) {
OrbisMsgDialogResult result;
memset(&result, 0, sizeof(result));
sceMsgDialogGetResult(&result);
return result.buttonId;
}
}
//c
return NO;
}
// now read frames and decode to s16le samples, from callback
static int dr_mp3_decode(void)
{
if (mp3.pData == NULL) return -1;
if (mp3.streamCursor <= dataSize.load())
{
int count = drmp3_read_pcm_frames_s16(&mp3, MP3_BUFFER_SIZE, &snd[0] /* &snd */);
if (count < 0) {
log_info("[MP3] Failed to read from file");
return 0;
}
else if (count == 0) {
memset(&snd, 0, MP3_BUFFER_SIZE * 2 * sizeof(short));
return -1;
}
off2 += count;
/* play audio sample after being decoded */
if (!(mp3.streamCursor % 1000)) {
log_info( "[MP3] audioout play %4d pFrames: %p, %zub %zu %zu %lu %.3f%%",
count, &snd[0], MP3_BUFFER_SIZE * 2 * sizeof(short),
off2, dataSize.load(), mp3.streamCursor,
(float)((float)mp3.streamCursor / (float)dataSize.load()) * 100.f);
}
}
return off2;
}
static void audio_PlayCallback(OrbisAudioSample* _buf2, unsigned int length, void* pdata)
{
const short* _buf = (short*)_buf2;
const int play_size = length * 2 * sizeof(short);
int handle = orbisAudioGetHandle(main_ch.load());
if (m_bPlaying.load())
{
static int decoded;
while (fill.load() < (1024 * 2)){
decoded = dr_mp3_decode();
if (decoded < 1) {
if (!(numframe % 500))
log_info("[MP3] Playing, but no audio samples decoded yet...");
memset(&snd[0], 0, sizeof(snd)); // fill with silence
log_info("[MP3] ended");
m_bPlaying = false; // break main loop
mp3data.clear();
break;
}
else {
memcpy(&play_buf[fill.load()], &snd[0], 4608); // we are doing in two step, sort of waste
fill += 1152 /* decoded samples */ * 2 /* channels */;
}
}
if (!(numframe % 500))
log_info("[MP3] play_buf samples: %d", fill.load());
if (!m_bPlaying.load()) {
orbisAudioSetCallback(main_ch.load(), 0, 0);
return;
}
/* write to audio device buffers */
memcpy((void*)_buf, &play_buf[0], play_size); // 1024 samples per channel, = 4096b
/* move remaining samples to head of buffer */
memcpy(&play_buf[0], &play_buf[1024 * 2], sizeof(play_buf) - play_size);
fill -= 1024 * 2;
if (fill.load() < 0){
fill = 0;
if (!(numframe % 500))
log_info("[MP3] no audio frames to play, fill: %d", fill.load());
log_info("[MP3] fill.load() < 0");
m_bPlaying = false;
mp3data.clear();
}
}
else // Not Playing, so clear buffer
{
if (!(numframe % 60))
log_info("[MP3] Inside audio_PlayCallback, not playing m_bPlaying: %d", m_bPlaying.load());
/* write silence to audio device buffers */
memset((void*)_buf, 0, play_size);
usleep(1000);
}
numframe++;
sceAudioOutOutput(handle, NULL);
}
/*================================== THEME SHIT BELOW =====================================*/
int on_extract_entry(const char *filename, void *arg)
{
log_debug("[ZIP] Extracted: %s", filename);
return 0;
}
bool extract_zip(const char* zip_file, const char* dest_path)
{
uint64_t progress[2];
struct zip_t *archive = zip_open(zip_file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'r');
if (!archive){
log_error("[ZIP] Failed to open archive: %s", zip_file);
return false;
}
progress[0] = 0;
progress[1] = zip_entries_total(archive);
zip_close(archive);
log_debug("[ZIP] Extracting ZIP (%lu files) to %s...", progress[1], dest_path);
if(zip_extract(zip_file, dest_path, on_extract_entry, progress) == 0) return true;
return false;
}
/*============================================================================================*/
bool power_settings(Power_control_sel sel)
{
if(Confirmation_Msg(fmt::format("{}?", power_menu_get_str(sel))) == YES){
#define SYSCORE_PID 1
int num = -1;
switch(sel){
case POWER_OFF_OPT:
num = 31;
break;
case RESTART_OPT:
num = 30;
break;
case SUSPEND_OPT:
num = 1;
break;
default:
return false;
}
if (syscall(37, SYSCORE_PID, num) != ITEMZCORE_SUCCESS) return false;
}
return true;
}
void* timer_thr(void* args){
sleep(5);
log_debug("[TIMER] Rebooting App");
raise(SIGQUIT);
return NULL;
}
void relaunch_timer_thread()
{
pthread_t id;
reboot_app = true;
pthread_create(&id, NULL, timer_thr, NULL);
}
/*==================================== UPDATE SHIT ===========================================*/
update_ret check_update_from_url(const char* tid = ITEMZFLOW_TID)
{
if(get->setting_bools[INTERNAL_UPDATE])
return IF_NO_UPDATE;
sceStoreApiCheckUpdate = (update_ret(*)(const char*))prx_func_loader(asset_path("../Media/store_api.prx"), "sceStoreApiCheckUpdate");
if(sceStoreApiCheckUpdate)
{
return sceStoreApiCheckUpdate(tid);
}
else
{
log_error("Failed to load store_api.prx");
return IF_UPDATE_ERROR;
}
}
void* CheckForUpdateThread(void*)
{
while (1) {
update_ret ret = check_update_from_url(ITEMZFLOW_TID);
if (ret == IF_UPDATE_FOUND){
log_info(" Update is available, the server reported a different Hash");
ani_notify(NOTIFI::INFO, getLangSTR(LANG_STR::OPT_UPDATE), "");
sleep(5 * 60);
}
else if(ret == IF_NO_UPDATE) {
sleep(5 * 60); // no update, check again in 5 minutes
}
else if(ret == IF_UPDATE_ERROR) {
log_info("Update Server is connectionn error, retrying in 60 secs");
sleep(60);
}
}
return 0;
}
void launch_update_thread()
{
pthread_t id;
pthread_create(&id, NULL, CheckForUpdateThread, NULL);// pthread_create(&id, NULL, timer_thr, NULL);
}
bool Launch_Store_URI()
{
sceStoreApiLaunchStore = (bool (*)(const char*))prx_func_loader(asset_path("../Media/store_api.prx"), "sceStoreApiLaunchStore");
if(sceStoreApiLaunchStore)
{
return sceStoreApiLaunchStore("Itemzflow");
}
else
{
log_error("Failed to load store_api.prx");
return false;
}
return false;
}
void ProgressUpdate(uint32_t prog, std::string fmt)
{
int status = sceMsgDialogUpdateStatus();
if (ORBIS_COMMON_DIALOG_STATUS_RUNNING == status) {
sceMsgDialogProgressBarSetValue(0, prog);
sceMsgDialogProgressBarSetMsg(0, fmt.c_str());
}
}
mp3_status_t MP3_Player(std::string path) {
TagLib::FileRef songf;
std::ifstream file;
if(path.empty() || path.size() < 3 || !if_exists(path.c_str()))
return MP3_STATUS_ERROR;
if (m_bPlaying.load() || retry_mp3_count >= 2) // ALREADY PLAYING
return MP3_STATUS_PLAYING;
current_song.song_title.clear();
current_song.song_artist.clear();
current_song.is_playing = false;
dataSize = 0;
if (path.substr(path.size() - 3, 3) != "mp3" && mp3_playlist.empty()) {
if(!is_folder(path.c_str()))
{
log_error("Not a folder: %s", path.c_str());
goto err;
}
FS_FILTER filter = fs_ret.filter;
fs_ret.filter = FS_MP3_ONLY;
index_items_from_dir_v2(path, mp3_playlist);
fs_ret.filter = filter;
//skip reserved index
if (mp3_playlist.size() <= 1) {
log_error("No MP3s in: %s", path.c_str());
mp3_playlist.clear();
goto err;
}
else {
log_info("Found %d MP3 files in %s", mp3_playlist.size()-1, path.c_str());
current_song.total_files = mp3_playlist.size()-1;
current_song.current_file = 1;
}
}
if (path.substr(path.size() - 3, 3) != "mp3" && mp3_playlist.size() > 1) {
if (current_song.current_file >= mp3_playlist.size()) {
log_info("Reached end of playlist, resetting index");
current_song.current_file = 1;
}
path = path + "/" + mp3_playlist[current_song.current_file].info.id;
if (path.substr(path.size() - 3, 3) != "mp3") {
log_error("Not a valid MP3 file: %s", path.c_str());
goto err;
}
}
else if (path.substr(path.size() - 3, 3) == "mp3") {
current_song.total_files = 1;
current_song.current_file = 0;
}
log_info("[MP3] Trying to play: %s", path.c_str());
songf = TagLib::FileRef(path.c_str());
if(songf.isNull() || !songf.tag())
{
log_error("Unknown File: %s", path.c_str());
goto err;
}
if (path.substr(path.size() - 3, 3) == "mp3") {
current_song.song_title = songf.tag()->title().isEmpty() ? path : songf.tag()->title().toCString(true);
current_song.song_artist = songf.tag()->artist().isEmpty() ? "Unknown Artist" : songf.tag()->artist().toCString(true);
}
else
{
current_song.song_title = songf.tag()->title().isEmpty() ? mp3_playlist[current_song.current_file].info.id : songf.tag()->title().toCString(true);
current_song.song_artist = songf.tag()->artist().isEmpty() ? "Unknown Artist" : songf.tag()->artist().toCString(true);
}
Config.outputSampleRate = 48000;
//load mp3 data for the drmp3 mp3 decoder
file.open(path.c_str(), std::ios::binary);
if(!file.is_open())
{
log_error("Failed to open file: %s", path.c_str());
goto err;
}
file.seekg(0, std::ios::end);
dataSize = file.tellg();
file.seekg(0, std::ios::beg);
//get the file size
if(dataSize == 0 || dataSize > MB(20))
{
log_error("MP3 Too big or is truncated: %s", path.c_str());
file.close();
goto err;
}
mp3data = std::vector<uint8_t>(std::istreambuf_iterator<char>(file), {});
file.close();
if (!drmp3_init_memory(&mp3, mp3data.data(), mp3data.size(), &Config)) {
mp3data.clear();
log_error("[MP3] drmp3_init_memory failed: %s", path.c_str());
goto err;
}
// attach audio callback
off2 = 0, fill = 0;
orbisAudioSetCallback(main_ch.load(), audio_PlayCallback, 0);
// start audio callback, and play
fmt::print("Playing: {0:} - {1:} ({2:})", current_song.song_title, current_song.song_artist, dataSize, (get->lang == 1 || get->lang == 2));
current_song.is_playing = m_bPlaying = true, orbisAudioResume(0);
current_song.current_file++;
GLES2_refresh_sysinfo();
return MP3_STATUS_STARTED;
err:
if (2 >= retry_mp3_count) {
ani_notify(NOTIFI::WARNING, getLangSTR(LANG_STR::FAILED_MP3), fmt::format("({0:d}/2)", retry_mp3_count+1));
retry_mp3_count++;
}
dataSize = 0;
mp3data.clear();
return MP3_STATUS_ERROR;
}
void Stop_Music(){
if(!m_bPlaying)
return;
log_info("Stopping MP3 Playback ...");
// set playing to false
current_song.is_playing = m_bPlaying = false;
//Stop audio callback
orbisAudioPause(0);
orbisAudioSetCallback(main_ch.load(), NULL, 0);
//Clear mp3 data
mp3data.clear();
mp3_playlist.clear();
get->setting_strings[MP3_PATH].clear();
//Clear mp3 decoder
drmp3_uninit(&mp3);
//Clear mp3 tags AND audio channel handle
current_song.song_artist = current_song.song_title = "";
retry_mp3_count = current_song.current_file = main_ch = current_song.total_files = 0;
}
bool do_update(std::string url) {
IPC_Client& ipc = IPC_Client::getInstance();
log_debug("[UPDATE] Starting Update...");
log_debug("[UPDATE] Updating...");
if (get->setting_bools[INTERNAL_UPDATE] && !is_connected_app) {
log_debug("[UPDATE] Daemon Not connected to app, exiting update mode ... ");
return false;
}
if (get->setting_bools[INTERNAL_UPDATE]) {
std::string tmp;
long ret = -1;
tmp = fmt::format("{}/update/if_update.pkg", url.c_str());
if ((ret = dl_from_url(tmp.c_str(), APP_PATH("../if_update.pkg"))) < 0 && if_exists(APP_PATH("../if_update.pkg"))) {
log_error("[UPDATE] Failed to download if_update.pkg ret: %i", ret);
return false;
}
ipc_msg = std::to_string(getpid());
IPC_Ret error = ipc.IPCSendCommand(IPC_Commands::INSTALL_IF_UPDATE, ipc_msg);
if (error != IPC_Ret::NO_ERROR) {
sceMsgDialogTerminate();
log_error("[UPDATE] IPC INSTALL UPDATE ERROR: %i", error);
return false;
}
log_debug("[UPDATE] Copied, Removing Temp Files");
log_debug("[UPDATE] Complete...");
raise(SIGQUIT);
} else {
if (!Launch_Store_URI()) {
log_error("[UPDATE] Failed to launch store uri");
return false;
}
}
return true;
}
void check_for_update_file() {
IPC_Client& ipc = IPC_Client::getInstance();
loadmsg(getLangSTR(LANG_STR::CHECH_UPDATE_IN_PROGRESS));
bool found = false;
log_debug("[STARTUP][UPDATE] Checking for update file ...");
if (if_exists("/user/update_tmp")) {
log_debug("[IF_UPDATE] Found Update temp folder, moving files back.."); //if updated via store
copy_dir("/user/update_tmp/covers", "/user/app/ITEM00001/covers");
copy_dir("/user/update_tmp/custom_app_names", "/user/app/ITEM00001/custom_app_names");
copyFile("/user/update_tmp/settings.ini", "/user/app/ITEM00001/settings.ini", false);
rmtree("/user/update_tmp");
unlink("/user/update_tmp");
log_debug("[IF_UPDATE] Moved files back, removing temp folder..");
} else {
log_info("No Update temp folder found");
}
if (!is_connected_app) {
log_debug("[STARTUP][UPDATE] Daemon Not connected to app, exiting update mode ... ");
sceMsgDialogTerminate();
return;
}
if (if_exists(APP_PATH("../if_update.pkg"))) {
log_debug("[STARTUP][UPDATE][HDD] if_update.pkg exists, starting update ...");
found = true;
} else if (usbpath() != -1 && if_exists(fmt::format("/mnt/usb{}/if_update.pkg", usbpath()).c_str())) {
log_debug("[STARTUP][UPDATE][USB] if_update.pkg exists, starting update ...");
copyFile(fmt::format("/mnt/usb{}/if_update.pkg", usbpath()), APP_PATH("../if_update.pkg"), false);
found = true;
} else {
log_debug("[STARTUP][UPDATE] if_update.pkg does not exist, exiting update mode ...");
sceMsgDialogTerminate();
return;
}
if (found) {
log_debug("[STARTUP][UPDATE] Update Found, Sending IPC Command for Update Installing ...");
ipc_msg = std::to_string(getpid());
log_info("[STARTUP] Sending PID: %s", ipc_msg.c_str());
IPC_Ret error = ipc.IPCSendCommand(IPC_Commands::INSTALL_IF_UPDATE, ipc_msg);
if (error != IPC_Ret::NO_ERROR) {
log_error("[STARTUP][UPDATE] IPC INSTALL UPDATE ERROR: %i", error);
sceMsgDialogTerminate();
return;
}
} else {
log_debug("[STARTUP][UPDATE] if_update.pkg does not exist, exiting update mode ...");
sceMsgDialogTerminate();
return;
}
raise(SIGQUIT);
}
/*============================================================================================*/
void notify(const char* message)
{
log_info(message);
sceKernelLoadStartModule("/system/common/lib/libSceSysUtil.sprx", 0, NULL, 0, 0, 0);
sceSysUtilSendSystemNotificationWithText(222, message);
}
// https://github.com/OSM-Made/PS4-Notify/blob/c6d259bc5bd4aa519f5b0ce4f5e27ef7cb01ffdd/Notify.cpp
void notifywithicon(const char* IconURI, const char* MessageFMT, ...)
{
NotifyBuffer Buffer;
va_list args;
va_start(args, MessageFMT);
vsprintf(Buffer.Message, MessageFMT, args);
va_end(args);
Buffer.Type = NotifyType::NotificationRequest;
Buffer.unk3 = 0;
Buffer.UseIconImageUri = 1;
Buffer.TargetId = -1;
strcpy(Buffer.Uri, IconURI);
sceKernelSendNotificationRequest(0, (char*)&Buffer, sizeof(Buffer), 0);
}
bool get_ip_address(std::string &ip)
{
int ret;
SceNetCtlInfo info;
ret = sceNetCtlGetInfo(14, &info);
if (ret < 0)
return false;
ip = info.ip_address;
return true;
}
void msgok(MSG_DIALOG::MSG_DIALOG_TYPE level, std::string in)
{
sceMsgDialogTerminate();
std::string out;
switch (level)
{
case MSG_DIALOG::NORMAL:
out = in;
break;
case MSG_DIALOG::FATAL:
log_fatal(in.c_str());
out = fmt::format("{0:} {1:}\n\n {2:}", getLangSTR(LANG_STR::FATAL_ERROR), in, getLangSTR(LANG_STR::PRESS_OK_CLOSE));
break;
case MSG_DIALOG::WARNING:
log_warn( in.c_str());
out = fmt::format("{0:} {1:}", getLangSTR(LANG_STR::WARNING2), in);
break;
}
sceMsgDialogInitialize();
OrbisMsgDialogParam param;
OrbisMsgDialogParamInitialize(&param);
param.mode = ORBIS_MSG_DIALOG_MODE_USER_MSG;
OrbisMsgDialogUserMessageParam userMsgParam;
memset(&userMsgParam, 0, sizeof(userMsgParam));
userMsgParam.msg = out.c_str();
userMsgParam.buttonType = ORBIS_MSG_DIALOG_BUTTON_TYPE_OK;
param.userMsgParam = &userMsgParam;
if (sceMsgDialogOpen(&param) < 0) log_fatal( "MsgD failed");
OrbisCommonDialogStatus stat;
while (1) {
stat = sceMsgDialogUpdateStatus();
if (stat == ORBIS_COMMON_DIALOG_STATUS_FINISHED)
{
OrbisMsgDialogResult result;
memset(&result, 0, sizeof(result));
if (0 > sceMsgDialogGetResult(&result)) log_fatal( "MsgD failed");
sceMsgDialogTerminate();
break;
}
}
if (level == MSG_DIALOG::FATAL) {
log_fatal(in.c_str());
raise(SIGQUIT);
}
return;
}
void loadmsg(std::string in)
{
OrbisMsgDialogButtonsParam buttonsParam;
OrbisMsgDialogUserMessageParam messageParam;
OrbisMsgDialogParam dialogParam;
sceMsgDialogInitialize();
OrbisMsgDialogParamInitialize(&dialogParam);
memset(&buttonsParam, 0x00, sizeof(buttonsParam));
memset(&messageParam, 0x00, sizeof(messageParam));
dialogParam.userMsgParam = &messageParam;
dialogParam.mode = ORBIS_MSG_DIALOG_MODE_USER_MSG;
messageParam.buttonType = ORBIS_MSG_DIALOG_BUTTON_TYPE_WAIT;
messageParam.msg = in.c_str();
sceMsgDialogOpen(&dialogParam);
return;
}
void scan_for_disc() {
//check if theres a disc
//std::lock_guard < std::mutex > lock(disc_lock);
char stack_tid[16];
int ret = -1;
memset( & stack_tid[0], 0, 16);
if ((ret = sceAppInstUtilAppGetInsertedDiscTitleId( & stack_tid[0])) >= 0 && !is_disc_inserted.load()) {
if (!all_apps.empty() && all_apps.size() > 1) {
for (int i = 0; i < all_apps[0].count.token_c + 1; i++) {
// skip if its an FPKG
if (all_apps[i].flags.is_fpkg)
continue;
// log_info("Disc inserted: %s : %i %s", stack_tid, i , all_apps[i].id.c_str());
if (all_apps[i].info.id.find( & stack_tid[0]) != std::string::npos) {
//Store the texture ID of the inserted disc
inserted_disc = i;
//inserted_disc: 1 CUSA00900 1 18
log_info("[UTIL] inserted_disc: %i %s %i %s %i", inserted_disc.load(), stack_tid, i, all_apps[i].info.id.c_str(), all_apps.size());
is_disc_inserted = true;
break;
}
}
}
} else if (ret == SCE_APP_INSTALLER_ERROR_DISC_NOT_INSERTED) {
// log_info("[UTIL] disc not inserted %x", ret);
inserted_disc = -999;
is_disc_inserted = false;
}
}
bool install_IF_Theme(std::string theme_path){
theme t;
int ret = -9;
int h, w;
std::string tmp;
fmt::print("[THEME][START] Installing Theme: {}", theme_path);
if(!if_exists(APP_PATH("theme"))){
log_error("[THEME] No Theme already exists, Making folder");
mkdir(APP_PATH("theme"), 0777);
}
else{
log_debug("[THEME] Theme already exists, Removing");
rmtree(APP_PATH("theme"));
log_debug("[THEME] Theme Removed");
}
log_debug("[THEME] Extracting Theme ...");
if(!extract_zip(theme_path.c_str(), APP_PATH("theme"))){
log_error("[THEME] Failed to extract Theme");
goto err;
}
log_debug("[THEME] Extracting Theme Done");
log_debug("[THEME] Getting Theme Info");
t.is_image = false;
t.using_sb = false;
get->setting_strings[FNT_PATH] = "/system_ex/app/NPXS20113/bdjstack/lib/fonts/SCE-PS3-RD-R-LATIN.TTF";
if(!if_exists(APP_PATH("theme/theme.ini")) || (ret = ini_parse(APP_PATH("theme/theme.ini"), theme_info, &t)) < 0){
log_error("[THEME][ERROR] Failed to Fetch Theme Info, ERROR %i", ret);
goto err;
}
/*============================ QA Theme CHECKS ================================================*/
if(t.version.empty() || t.name.empty() || t.author.empty() || t.date.empty()){
log_error("[THEME][ERROR] Theme Info is missing");
goto err;
}
if(t.is_image && (!if_exists(APP_PATH("theme/background.png")) || !is_png_vaild(APP_PATH("theme/background.png"), &h, &w))){
log_error("[THEME][ERROR] No vaild Theme Image but the INI reports its using one");
goto err;
}
if(t.has_font && !if_exists(APP_PATH("theme/font.ttf")) ){
log_error("[THEME][ERROR] No vaild FONT but the INI reports its using one");
goto err;
}
for(int i = 0; i < sizeof required_theme_files / sizeof required_theme_files[0]; i++){
tmp = fmt::format("{}{}", APP_PATH(""), required_theme_files[i]);
if(!if_exists(tmp.c_str()) || !is_png_vaild(tmp.c_str(), &h, &w)){
log_error("[THEME][ERROR] Error Loading file %s which is required for themes, maybe its invaild/corrupt?", &tmp[0]);
goto err;
}
}
if(t.using_sb && !if_exists(APP_PATH("theme/shader.bin"))){
log_error("[THEME][ERROR] No Shader Binary but the INI reports its using one");
goto err;
}
else if(t.using_sb){
int programID = -1;
const char* data = (const char*)orbisFileGetFileContent(APP_PATH("theme/shader.bin"));
if(data == NULL){
log_debug("[THEME][ERROR] can't load shader.bin");
goto err;
}
else{
programID = BuildProgram(p_vs1, data, p_vs1_length, _orbisFile_lastopenFile_size);
if(programID == -1){
log_debug("[THEME][ERROR] Shader Testing Failed!!!");
free((void*)data);
goto err;
}
else
log_debug("[THEME][INFO] Shader Built... programID: %i", programID);
// NO leaks pls
glDeleteProgram(programID);
free((void*)data);
}
}
log_debug("[THEME] ======== Theme Info =======");
fmt::print("[THEME] Name: {}", t.name);
fmt::print("[THEME] Version: {}", t.version);
fmt::print("[THEME] Date: {}", t.date);
fmt::print("[THEME] Author: {}", t.author);
log_debug("[THEME] Image: %s", t.is_image ? "Yes" : "No");
log_debug("[THEME] Font: %s", t.has_font ? "Yes" : "No");
log_debug("[THEME] Shader: %s", t.using_sb ? "Yes" : "No");
log_debug("[THEME] ======== End of Theme Info =======");
log_debug("[THEME] Freeing Theme Info ...");
get->setting_bools[has_image] = t.is_image;
get->setting_bools[using_sb] = t.using_sb;
get->setting_bools[using_theme] = true;
if(!SaveOptions(get)){
log_error("[THEME] Failed to save Theme Options");
goto err;
}
zip_create(APP_PATH("Reset Theme to Default.zip"), &if_d_zip[0], 200);
if(usbpath() != -1){
log_debug("[THEME] USB Path is set, updating USB Theme");
tmp = fmt::format("/mnt/usb{}/Reset Theme to Default.zip", usbpath());
zip_create(tmp.c_str(), &if_d_zip[0], 200);
}
fmt::print("[THEME] Theme Installed: {}", t.name);
sceMsgDialogTerminate();
return true;
err:
log_error("[THEME][ERROR] Freeing Theme Info ...");
log_error("[THEME][ERROR] Deleting Theme Dir ...");
rmtree(APP_PATH("theme"));
log_error("[THEME][ERROR] Theme Dir Deleted");
log_error("[THEME][ERROR] Resetting IF Settings ...");
get->setting_strings[FNT_PATH] = "/system_ex/app/NPXS20113/bdjstack/lib/fonts/SCE-PS3-RD-R-LATIN.TTF";
get->setting_bools[using_theme] = false;
if(!SaveOptions(get))
log_error("[THEME][ERROR] Failed to save Theme Options");
log_error("[THEME][ERROR] Complete.. returning....");
sceMsgDialogTerminate();
return false;
}
uint32_t Launch_App(std::string TITLE_ID, bool silent, int index) {
uint32_t sys_res = -1;
u32 userId = -1;
int libcmi = sceKernelLoadStartModule("/system/common/lib/libSceSystemService.sprx", 0, NULL, 0, 0, 0);
if (libcmi > 0)
{
fmt::print("Starting action Launch_App({0:}, {1:d})", TITLE_ID, silent);
fmt::print("sceUserServiceGetForegroundUser {0:#x}", sceUserServiceGetForegroundUser(&userId));
fmt::print("Launching App for User: {0:#x}", userId);
LncAppParam param;
param.sz = sizeof(LncAppParam);
param.user_id = userId;
param.app_opt = 0;
param.crash_report = 0;
param.check_flag = SkipSystemUpdateCheck;
sys_res = sceLncUtilLaunchApp(TITLE_ID.c_str(), NULL, &param);
if (IS_ERROR(sys_res))
{
if (!silent) {
fmt::print("[ERROR] Switch {0:#x}", sys_res);
switch (sys_res) {
case SCE_LNC_ERROR_APP_NOT_FOUND: {
//msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::APP_NOT_FOUND));
if(Confirmation_Msg(fmt::format("{0:}\n\n{1:}\n{2:}", getLangSTR(LANG_STR::IF_LAUNCH_TROUBLESHOOTER), getLangSTR(LANG_STR::LAUNCH_FAILED_BC_NOT_FOUND), getLangSTR(LANG_STR::CONFIRMATION_2))) == YES){
if(Fix_Game_In_DB(all_apps, index, all_apps[index].flags.is_fpkg))
ani_notify(NOTIFI::GAME, getLangSTR(LANG_STR::GAME_INSERT_SUCCESSFUL), getLangSTR(LANG_STR::REPAIR_ATTEMPTED1));
else
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::GAME_INSERT_FAILED));
}
break;
}
case SCE_LNC_UTIL_ERROR_ALREADY_RUNNING: {
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::APP_OPENED));
break;
}
case SCE_LNC_UTIL_ERROR_APPHOME_EBOOTBIN_NOT_FOUND: {
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::MISSING_EBOOT));
break;
}
case SCE_LNC_UTIL_ERROR_APPHOME_PARAMSFO_NOT_FOUND: {
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::MISSING_SFO));
break;
}
case SCE_LNC_UTIL_ERROR_NO_SFOKEY_IN_APP_INFO: {
//msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::CORRUPT_SFO));
if(Confirmation_Msg(fmt::format("{0:}\n\n{1:}\n{2:}", getLangSTR(LANG_STR::IF_LAUNCH_TROUBLESHOOTER), getLangSTR(LANG_STR::FIX_BROKEN_SFO_DB), getLangSTR(LANG_STR::CONFIRMATION_3))) == YES){
if(Fix_Game_In_DB(all_apps, index, all_apps[index].flags.is_fpkg))
ani_notify(NOTIFI::GAME, getLangSTR(LANG_STR::REPAIR_ATTEMPTED), getLangSTR(LANG_STR::REPAIR_ATTEMPTED1));
else
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::GAME_INSERT_FAILED));
}
break;
}
case SCE_LNC_UTIL_ERROR_ALREADY_RUNNING_KILL_NEEDED: {
log_debug("ALREADY RUNNING KILL NEEDED");
break;
}
case SCE_LNC_UTIL_ERROR_ALREADY_RUNNING_SUSPEND_NEEDED: {
log_debug("ALREADY RUNNING SUSPEND NEEDED");
break;
}
case SCE_LNC_UTIL_ERROR_SETUP_FS_SANDBOX: {
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::APP_UNL));
break;
}
case SCE_LNC_UTIL_ERROR_INVALID_TITLE_ID: {
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::ID_NOT_VAILD));
break;
}
case PROCCESS_STARTER_OP_NOT_SUPPORTED: {
if(TITLE_ID == APP_HOME_HOST_TID)
msgok(MSG_DIALOG::WARNING, getLangSTR(LANG_STR::LNC_TOO_MANY_ROOT_FILES));
break;
}
default: {
msgok(MSG_DIALOG::WARNING, fmt::format("{0:}: {1:#x}", getLangSTR(LANG_STR::LAUNCH_ERROR),sys_res));
break;
}
}
}
}
fmt::print("launch ret {0:#x}", sys_res);
}
else {
if(!silent)
msgok(MSG_DIALOG::WARNING, fmt::format("{0:}: {1:#x}", getLangSTR(LANG_STR::LAUNCH_ERROR),libcmi));
}
return sys_res;
}
bool is_sfo(const char* input_file_name) {
FILE* file = fopen(input_file_name, "rb");
if (file == NULL) return false;
// Get SFO header offset
uint32_t magic;
fread(&magic, 4, 1, file);
if (magic == 1179865088) { // Param.sfo file
rewind(file);
}
else
{
log_error("[SFO] Not a param.sfo file. %s", input_file_name);
fclose(file);
return false;
}
fclose(file);
return true;
}
bool is_fpkg(std::string pkg_path) {
PKG_HDR hdr;
// Open path
int pkg = open(pkg_path.c_str(), 0, 0);
if (pkg < 0){
fmt::print("[ERROR] Error opening file: {}", pkg_path);
return false;
}
lseek(pkg, 0, SEEK_SET);
//first byte
read(pkg, &hdr, sizeof(PKG_HDR));
close(pkg);
//fmt::print("pkg_path: {0:} | hdr.magic: {1:x}", pkg_path, hdr.magic);
return (hdr.flags & FPKG) == 0;
}
bool dlc_pkg_details(const char* src_dest, DLC_PKG_DETAILS &details) {
// Read PKG header
struct pkg_header hdr;
//char title[256];
static const uint8_t pkg_magic[] = { '\x7F', 'C', 'N', 'T' };
// Open path
int pkg = sceKernelOpen(src_dest, O_RDONLY, 0);
if (pkg < 0){
log_error("Error opening file: %s, err: %s", src_dest, strerror(errno));
return false;
}
sceKernelLseek(pkg, 0, SEEK_SET);
sceKernelRead(pkg, &hdr, sizeof(struct pkg_header));
if (memcmp(hdr.magic, pkg_magic, sizeof(pkg_magic)) != 0) {
log_error("PKG Format is wrong");
sceKernelClose(pkg);
return false;
}
sceKernelClose(pkg);
details.contentid = std::string(hdr.content_id);
if(!extract_sfo_from_pkg(src_dest, "/user/app/ITEM00001/tmp_param.sfo")){
log_error("Could not extract param.sfo");
return false;
}
//TODO make more effecient
std::vector<uint8_t> sfo_data = readFile("/user/app/ITEM00001/tmp_param.sfo");
if(sfo_data.empty()){
log_error("Could not read param.sfo");
return false;
}
SfoReader sfo(sfo_data);
details.name = sanitizeString(sfo.GetValueFor<std::string>("TITLE"));
details.version = sfo.GetValueFor<std::string>("VERSION");
details.esd.insert(std::pair<std::string, std::string>("IRO_TAG", sfo.GetValueFor<std::string>("IRO_TAG")));
for (int i = 0; i <= 30; i++) {
std::string key = fmt::format("TITLE_{0:}{1:d}", (i < 10) ? "0" : "", i);
details.esd.insert(std::pair<std::string, std::string>(key, sanitizeString(sfo.GetValueFor<std::string>(key))));
}
//log_info("[DLC] Content ID: %s", details.contentid.c_str());
//log_info("[DLC] Version: %s", details.version.c_str());
log_info("[DLC] Title: %s", details.name.c_str());
return true;
}
void rebuild_db(){
if (get->sort_cat == NO_CATEGORY_FILTER ||
(get->sort_cat != NO_CATEGORY_FILTER && Confirmation_Msg(getLangSTR(LANG_STR::CAT_REBUILD_WARNING)) == YES))
{
progstart((char *)getLangSTR(LANG_STR::REBUILDING_FOR_FPKG).c_str());
int failures = 0;
for (int i = 1; i <= all_apps[0].count.HDD_count; i++)
{
bool is_if = ((all_apps[i].info.id == "ITEM00001") || (all_apps[i].info.id == "ITEM99999"));
if (!all_apps[i].flags.is_fpkg || is_if)
{ // if its not an fpkg or Itemzflow, skip
fmt::print("Skipping {}: {}", is_if ? "IF" : "Retail Game", all_apps[i].info.name);
continue;
}
if (i > all_apps[0].count.HDD_count){
log_info("Skipping external HDD app: %s ???", all_apps[i].info.name.c_str());
continue;
}
int prog = (uint32_t)(((float)i / all_apps[0].count.HDD_count) * 100.f);
ProgSetMessagewText(prog, fmt::format("{0:}\n{1:}\n{2:}\n\n {3:} {4:d}\n{5:} {6:d}", getLangSTR(LANG_STR::REBUILDING_FOR_FPKG), all_apps[i].info.name, all_apps[i].info.id, getLangSTR(LANG_STR::CURRENT_APP), i, getLangSTR(LANG_STR::TOTAL_NUM_OF_APPS), all_apps[0].count.HDD_count).c_str());
log_info("App Info: %s | %i", all_apps[i].info.name.c_str(), i);
// function also replaces special chars for SQL smt
if (Fix_Game_In_DB(all_apps, i, all_apps[i].flags.is_ext_hdd))
log_info("Game Fixed: %s", all_apps[i].info.name.c_str());
else
{
log_error("Game NOT Fixed: %s", all_apps[i].info.name.c_str());
failures++;
}
}
sceMsgDialogTerminate();
loadmsg((char *)getLangSTR(LANG_STR::REBUILDING_ADDCONT).c_str());
addcont_dlc_rebuild("/system_data/priv/mms/addcont.db", false);
//addcont_dlc_rebuild("/system_data/priv/mms/addcont.db", true);
msgok(MSG_DIALOG::NORMAL, fmt::format("{0:}: {1:d}\n{2:}: {3:d}", getLangSTR(LANG_STR::NUMB_OF_FIXED_APPS), all_apps[0].count.HDD_count-failures, getLangSTR(LANG_STR::NOT_FIXED), failures));
}
}
void rebuild_dlc_db(){
loadmsg((char *)getLangSTR(LANG_STR::REBUILDING_ADDCONT).c_str());
addcont_dlc_rebuild("/system_data/priv/mms/addcont.db", true);
if(addcont_dlc_rebuild("/system_data/priv/mms/addcont.db", false))
ani_notify(NOTIFI::SUCCESS, getLangSTR(LANG_STR::ADDCONT_REBUILT), "");
else
ani_notify(NOTIFI::WARNING, getLangSTR(LANG_STR::ADDCONT_FAILED), "");
sceMsgDialogTerminate();
}
void print_Apps_Array(ThreadSafeVector<item_t> &b)
{
for (int i = 0; i <= b.at(0).count.token_c; i++)
{
fmt::print("b[{0:d}].token_d[0].off ptr: {1:}", i, b.at(i).info.id);
fmt::print("b[{0:d}].token_d[1].off ptr: {1:}", i, b.at(i).info.name);
}
}
void delete_apps_array(ThreadSafeVector<item_t> &apps_arr)
{
if(apps_arr.empty())
return;
for (int i = 1; i <= apps_arr.at(0).count.token_c; i++)
{
GLuint text = apps_arr.at(i).icon.texture.load();
if (text > GL_NULL){
glDeleteTextures(1, &text);
apps_arr.at(i).icon.texture = GL_NULL;
}
}
apps_arr.clear();
}
std::ifstream::pos_type file_size(const char* filename)
{
std::ifstream in(filename, std::ifstream::ate | std::ifstream::binary);
return in.tellg();
}
std::string NormalizeFWVersion(int version) {
std::string versionString = fmt::format("{:x}", version);
versionString.insert(1, ".");
std::string::size_type pos;
while ((pos = versionString.find("0000")) != std::string::npos) {
versionString.erase(pos, 4); // 4 is the length of "0000"
}
return versionString;
}
Reference in New Issue View Git Blame Copy Permalink