The-Homebrew-Cloud/homebrew_on_menu_plugin
2
0
Fork 0
mirror of https://github.com/wiiu-env/homebrew_on_menu_plugin.git synced 2024-06-02 17:48:43 +02:00
Code Issues Packages Projects Releases Wiki Activity
b4b8138150
homebrew_on_menu_plugin/src/main.cpp

429 lines
16 KiB
C++
Raw Blame History

#include <wups.h>
#include <zlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <exception>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <coreinit/title.h>
#include <coreinit/cache.h>
#include <coreinit/systeminfo.h>
#include <coreinit/mcp.h>
#include <coreinit/filesystem.h>
#include <coreinit/systeminfo.h>
#include <coreinit/memorymap.h>
#include <coreinit/dynload.h>
#include <sysapp/title.h>
#include <nn/acp.h>
#include <nsysnet/socket.h>
#include <coreinit/ios.h>
#include <vpad/input.h>
#include <utils/logger.h>
#include <map>
#include <utils/utils.h>
#include "utils/StringTools.h"
#include <fs/DirList.h>
#include <wut_romfs_dev.h>
#include "filelist.h"
#include "readFileWrapper.h"
#include "romfs_helper.h"
WUPS_PLUGIN_NAME("Homebrew SysLauncher");
WUPS_PLUGIN_DESCRIPTION("Allows the user to load homebrew from the System Menu");
WUPS_PLUGIN_VERSION("0.1");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("GPL");
char gIconCache[65580] __attribute__((section(".data")));
ACPMetaXml gLaunchXML __attribute__((section(".data")));
MCPTitleListType template_title __attribute__((section(".data")));
BOOL gHomebrewLaunched __attribute__((section(".data")));
WUPS_USE_WUT_CRT()
INITIALIZE_PLUGIN() {
memset((void*) &template_title,0,sizeof(template_title));
memset((void*) &gLaunchXML,0,sizeof(gLaunchXML));
memset((void*) &gFileInfos,0,sizeof(gFileInfos));
memset((void*) &gFileReadInformation,0,sizeof(gFileReadInformation));
memset((void*) &gIconCache,0,sizeof(gIconCache));
gHomebrewLaunched = FALSE;
}
ON_APPLICATION_START(args) {
socket_lib_init();
log_init();
DEBUG_FUNCTION_LINE("IN PLUGIN\n");
if(_SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_HEALTH_AND_SAFETY) != OSGetTitleID()) {
DEBUG_FUNCTION_LINE("gHomebrewLaunched to FALSE\n");
gHomebrewLaunched = FALSE;
}
}
ON_APPLICATION_END() {
DeInitAllFiles();
unmountAllRomfs();
}
void fillXmlForTitleID(uint32_t titleid_upper, uint32_t titleid_lower, ACPMetaXml* out_buf) {
if(titleid_lower >= FILE_INFO_SIZE) {
return;
}
out_buf->title_id = ((uint64_t)titleid_upper * 0x100000000) + titleid_lower;
strncpy(out_buf->longname_en,gFileInfos[titleid_lower].name,511);
strncpy(out_buf->shortname_en,gFileInfos[titleid_lower].name,255);
strncpy(out_buf->publisher_en,gFileInfos[titleid_lower].name,255);
out_buf->e_manual = 1;
out_buf->e_manual_version = 0;
out_buf->title_version = 1;
out_buf->network_use = 1;
out_buf->launching_flag = 4;
out_buf->online_account_use = 1;
out_buf->os_version = 0x000500101000400A;
out_buf->region = 0xFFFFFFFF;
out_buf->common_save_size = 0x0000000001790000;
out_buf->group_id = 0x400;
out_buf->drc_use = 1;
out_buf->version = 1;
out_buf->reserved_flag0 = 0x00010001;
out_buf->reserved_flag6 = 0x00000003;
out_buf->pc_usk = 128;
strncpy(out_buf->product_code,"WUP-P-HBLD",strlen("WUP-P-HBLD"));
strncpy(out_buf->content_platform,"WUP",strlen("WUP"));
strncpy(out_buf->company_code,"0001",strlen("0001"));
}
DECL_FUNCTION(int32_t, MCP_TitleList, uint32_t handle, uint32_t* outTitleCount, MCPTitleListType* titleList, uint32_t size) {
int32_t result = real_MCP_TitleList(handle, outTitleCount, titleList, size);
uint32_t titlecount = *outTitleCount;
DirList dirList("fs:/vol/external01/wiiu/apps", ".rpx,.wbf", DirList::Files | DirList::CheckSubfolders, 1);
dirList.SortList();
int j = 0;
for(int i = 0; i < dirList.GetFilecount(); i++) {
if(j >= FILE_INFO_SIZE) {
DEBUG_FUNCTION_LINE("TOO MANY TITLES\n");
break;
}
//! skip our own application in the listing
if(strcasecmp(dirList.GetFilename(i), "homebrew_launcher.rpx") == 0) {
continue;
}
//! skip our own application in the listing
if(strcasecmp(dirList.GetFilename(i), "temp.rpx") == 0) {
continue;
}
//! skip hidden linux and mac files
if(dirList.GetFilename(i)[0] == '.' || dirList.GetFilename(i)[0] == '_') {
continue;
}
char buffer [25];
snprintf(buffer,25,"/custom/%08X%08X", 0x0005000F, j);
strcpy(template_title.path,buffer);
char * repl = (char*)"fs:/vol/external01/";
char * with = (char*)"";
char * input = (char*) dirList.GetFilepath(i);
char * path = StringTools::str_replace(input,repl, with);
if(path != NULL) {
strncpy(gFileInfos[j].path,path, 255);
free(path);
}
strncpy(gFileInfos[j].name, dirList.GetFilename(i),255);
gFileInfos[j].source = 0; //SD Card;
DEBUG_FUNCTION_LINE("[%d] %s\n",j, gFileInfos[j].path);
const char * indexedDevice = "mlc";
strcpy(template_title.indexedDevice,indexedDevice);
if(StringTools::EndsWith(gFileInfos[j].name, ".wbf")) {
template_title.appType = MCP_APP_TYPE_GAME;
} else {
// System apps don't have a splash screen.
template_title.appType = MCP_APP_TYPE_SYSTEM_APPS;
}
template_title.titleId = 0x0005000F00000000 + j;
template_title.titleVersion = 1;
template_title.groupId = 0x400;
template_title.osVersion = OSGetOSID();
template_title.sdkVersion = __OSGetProcessSDKVersion();
template_title.unk0x60 = 0;
memcpy(&(titleList[titlecount]), &template_title,sizeof(template_title));
titlecount++;
j++;
}
*outTitleCount = titlecount;
return result;
}
DECL_FUNCTION(int32_t, MCP_GetTitleInfoByTitleAndDevice, uint32_t mcp_handle, uint32_t titleid_lower_1, uint32_t titleid_upper, uint32_t titleid_lower_2, uint32_t unknown, MCPTitleListType* title) {
if(gHomebrewLaunched) {
memcpy(title, &(template_title), sizeof(MCPTitleListType));
} else if(titleid_upper == 0x0005000F) {
char buffer [25];
snprintf(buffer,25,"/custom/%08X%08X", titleid_upper, titleid_lower_2);
strcpy(template_title.path,buffer);
template_title.titleId = 0x0005000F00000000 + titleid_lower_1;
memcpy(title, &(template_title), sizeof(MCPTitleListType));
return 0;
}
int result = real_MCP_GetTitleInfoByTitleAndDevice(mcp_handle, titleid_lower_1, titleid_upper, titleid_lower_2, unknown, title);
return result;
}
typedef struct __attribute((packed)) {
uint32_t command;
uint32_t target;
uint32_t filesize;
uint32_t fileoffset;
char path[256];
}
LOAD_REQUEST;
int32_t getRPXInfoForID(uint32_t id, romfs_fileInfo * info);
DECL_FUNCTION(int32_t, ACPCheckTitleLaunchByTitleListTypeEx, MCPTitleListType* title, uint32_t u2) {
if((title->titleId & 0x0005000F00000000) == 0x0005000F00000000 && (uint32_t)(title->titleId & 0xFFFFFFFF) < FILE_INFO_SIZE) {
DEBUG_FUNCTION_LINE("Started homebrew\n");
gHomebrewLaunched = TRUE;
fillXmlForTitleID((title->titleId & 0xFFFFFFFF00000000) >> 32,(title->titleId & 0xFFFFFFFF), &gLaunchXML);
LOAD_REQUEST request;
memset(&request, 0, sizeof(request));
request.command = 0xFC; // IPC_CUSTOM_LOAD_CUSTOM_RPX;
request.target = 0; // LOAD_FILE_TARGET_SD_CARD
request.filesize = 0; // unknown
request.fileoffset = 0; //
romfs_fileInfo info;
int res = getRPXInfoForID((title->titleId & 0xFFFFFFFF),&info);
if(res >= 0) {
request.filesize = ((uint32_t*)&info.length)[1];
request.fileoffset = ((uint32_t*)&info.offset)[1];
loadFileIntoBuffer((title->titleId & 0xFFFFFFFF),"meta/iconTex.tga",gIconCache,sizeof(gIconCache));
}
strncpy(request.path, gFileInfos[(uint32_t)(title->titleId & 0xFFFFFFFF)].path, 255);
DEBUG_FUNCTION_LINE("Loading file %s size: %08X offset: %08X\n", request.path, request.filesize, request.fileoffset);
DCFlushRange(&request, sizeof(LOAD_REQUEST));
int mcpFd = IOS_Open("/dev/mcp", (IOSOpenMode)0);
if(mcpFd >= 0) {
int out = 0;
IOS_Ioctl(mcpFd, 100, &request, sizeof(request), &out, sizeof(out));
IOS_Close(mcpFd);
}
return 0;
}
int result = real_ACPCheckTitleLaunchByTitleListTypeEx(title, u2);
return result;
}
DECL_FUNCTION(int, FSOpenFile, FSClient *client, FSCmdBlock *block, char *path, const char *mode, int *handle, int error) {
char * start = "/vol/storage_mlc01/sys/title/0005000F";
char * icon = ".tga";
char * iconTex = "iconTex.tga";
char * sound = ".btsnd";
if(StringTools::EndsWith(path,icon) || StringTools::EndsWith(path,sound)) {
if(strncmp(path,start,strlen(start)) == 0) {
int res = FS_STATUS_NOT_FOUND;
if(StringTools::EndsWith(path,iconTex)) {
// fallback to dummy icon if loaded homebrew is no .wbf
//*handle = 0x1337;
res = FS_STATUS_NOT_FOUND;
}
uint32_t val;
char * id = path+1+strlen(start);
id[8] = 0;
char * ending = id+9;
sscanf(id,"%08X", &val);
if(FSOpenFile_for_ID(val, ending, handle) < 0) {
return res;
}
return FS_STATUS_OK;
} else if(gHomebrewLaunched) {
socket_lib_init();
log_init();
if(StringTools::EndsWith(path,iconTex)) {
*handle = 0x13371337;
DEBUG_FUNCTION_LINE("yooo let's do it\n");
return FS_STATUS_OK;
}else{
DEBUG_FUNCTION_LINE("%s\n",path);
}
}
}
int result = real_FSOpenFile(client, block, path, mode, handle, error);
return result;
}
DECL_FUNCTION(FSStatus, FSCloseFile, FSClient *client, FSCmdBlock *block, FSFileHandle handle, uint32_t flags) {
if(handle == 0x13371337) {
return FS_STATUS_OK;
}
if((handle & 0xFF000000) == 0xFF000000) {
int32_t fd = (handle & 0x00000FFF);
int32_t romid = (handle & 0x00FFF000) >> 12;
DEBUG_FUNCTION_LINE("Close %d %d\n", fd, romid);
DeInitFile(fd);
if(gFileInfos[romid].openedFiles--) {
if(gFileInfos[romid].openedFiles <= 0) {
DEBUG_FUNCTION_LINE("unmount romfs no more handles\n");
unmountRomfs(romid);
}
}
//unmountAllRomfs();
return FS_STATUS_OK;
}
return real_FSCloseFile(client,block,handle,flags);
}
DECL_FUNCTION(FSStatus, FSReadFile, FSClient *client, FSCmdBlock *block, uint8_t *buffer, uint32_t size, uint32_t count, FSFileHandle handle,uint32_t unk1, uint32_t flags) {
if(handle == 0x13371337) {
int cpySize = size*count;
if(sizeof(gIconCache) < cpySize) {
cpySize = sizeof(gIconCache);
}
memcpy(buffer, gIconCache, cpySize);
DEBUG_FUNCTION_LINE("DUMMY\n");
return (FSStatus)(cpySize/size);
}
if((handle & 0xFF000000) == 0xFF000000) {
int32_t fd = (handle & 0x00000FFF);
int32_t romid = (handle & 0x00FFF000) >> 12;
DEBUG_FUNCTION_LINE("READ %d from %d rom: %d\n", size*count, fd, romid);
int readSize = readFile(fd, buffer, (size*count));
return (FSStatus)(readSize / size);
}
FSStatus result = real_FSReadFile(client, block, buffer, size, count, handle, unk1, flags);
return result;
}
DECL_FUNCTION(int32_t, ACPGetTitleMetaXmlByDevice, uint32_t titleid_upper, uint32_t titleid_lower, ACPMetaXml* out_buf, uint32_t device, uint32_t u1) {
int result = real_ACPGetTitleMetaXmlByDevice(titleid_upper, titleid_lower, out_buf, device,u1);
if(titleid_upper == 0x0005000F) {
fillXmlForTitleID(titleid_upper,titleid_lower, out_buf);
result = 0;
}
return result;
}
DECL_FUNCTION(int32_t, ACPGetTitleMetaDirByDevice, uint32_t titleid_upper, uint32_t titleid_lower, char* out_buf, uint32_t size, int device) {
if(titleid_upper == 0x0005000F) {
snprintf(out_buf,53,"/vol/storage_mlc01/sys/title/%08X/%08X/meta", titleid_upper, titleid_lower);
return 0;
}
int result = real_ACPGetTitleMetaDirByDevice(titleid_upper, titleid_lower, out_buf, size, device);
return result;
}
DECL_FUNCTION(int32_t, _SYSLaunchTitleByPathFromLauncher, char* pathToLoad, uint32_t u2) {
const char * start = "/custom/";
if(strncmp(pathToLoad,start,strlen(start)) == 0) {
strcpy(template_title.path,pathToLoad);
uint64_t titleID = _SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_HEALTH_AND_SAFETY);
snprintf(pathToLoad,47,"/vol/storage_mlc01/sys/title/%08x/%08x", (uint32_t) (titleID >> 32), (uint32_t) (0x00000000FFFFFFFF & titleID));
}
int32_t result = real__SYSLaunchTitleByPathFromLauncher(pathToLoad, strlen(pathToLoad));
return result;
}
DECL_FUNCTION(int32_t, ACPGetLaunchMetaXml, ACPMetaXml * metaxml) {
int result = real_ACPGetLaunchMetaXml(metaxml);
if(gHomebrewLaunched) {
memcpy(metaxml, &gLaunchXML, sizeof(gLaunchXML));
}
return result;
}
DECL_FUNCTION(uint32_t, ACPGetApplicationBox,uint32_t * u1, uint32_t * u2, uint32_t u3, uint32_t u4) {
if(u3 == 0x0005000F) {
uint64_t titleID = _SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_HEALTH_AND_SAFETY);
u3 = (uint32_t) (titleID >> 32);
u4 = (uint32_t) (0x00000000FFFFFFFF & titleID);
}
uint32_t result = real_ACPGetApplicationBox(u1,u2,u3,u4);
return result;
}
DECL_FUNCTION(uint32_t, PatchChkStart__3RplFRCQ3_2nn6drmapp8StartArg, uint32_t * param ) {
if(param[2] == 0x0005000F) {
uint64_t titleID = _SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_HEALTH_AND_SAFETY);
param[2] = (uint32_t) (titleID >> 32);
param[3] = (uint32_t) (0x00000000FFFFFFFF & titleID);
}
uint32_t result = real_PatchChkStart__3RplFRCQ3_2nn6drmapp8StartArg(param);
return result;
}
DECL_FUNCTION(uint32_t, MCP_RightCheckLaunchable, uint32_t * u1, uint32_t * u2, uint32_t u3, uint32_t u4, uint32_t u5) {
if(u3 == 0x0005000F) {
uint64_t titleID = _SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_HEALTH_AND_SAFETY);
u3 = (uint32_t) (titleID >> 32);
u4 = (uint32_t) (0x00000000FFFFFFFF & titleID);
}
uint32_t result = real_MCP_RightCheckLaunchable(u1,u2,u3,u4,u5);
return result;
}
DECL_FUNCTION(int32_t, HBM_NN_ACP_ACPGetTitleMetaXmlByDevice, uint32_t titleid_upper, uint32_t titleid_lower, ACPMetaXml* metaxml, uint32_t device) {
if(gHomebrewLaunched) {
memcpy(metaxml, &gLaunchXML, sizeof(gLaunchXML));
return 0;
}
int result = real_HBM_NN_ACP_ACPGetTitleMetaXmlByDevice(titleid_upper, titleid_lower, metaxml, device);
return result;
}
WUPS_MUST_REPLACE_PHYSICAL(HBM_NN_ACP_ACPGetTitleMetaXmlByDevice, 0x2E36CE44, 0x0E36CE44);
WUPS_MUST_REPLACE(ACPGetApplicationBox, WUPS_LOADER_LIBRARY_NN_ACP, ACPGetApplicationBox );
WUPS_MUST_REPLACE(PatchChkStart__3RplFRCQ3_2nn6drmapp8StartArg, WUPS_LOADER_LIBRARY_DRMAPP, PatchChkStart__3RplFRCQ3_2nn6drmapp8StartArg );
WUPS_MUST_REPLACE(MCP_RightCheckLaunchable, WUPS_LOADER_LIBRARY_COREINIT, MCP_RightCheckLaunchable );
WUPS_MUST_REPLACE(FSReadFile, WUPS_LOADER_LIBRARY_COREINIT, FSReadFile);
WUPS_MUST_REPLACE(FSOpenFile, WUPS_LOADER_LIBRARY_COREINIT, FSOpenFile);
WUPS_MUST_REPLACE(FSCloseFile, WUPS_LOADER_LIBRARY_COREINIT, FSCloseFile);
WUPS_MUST_REPLACE(MCP_TitleList, WUPS_LOADER_LIBRARY_COREINIT, MCP_TitleList);
WUPS_MUST_REPLACE(MCP_GetTitleInfoByTitleAndDevice, WUPS_LOADER_LIBRARY_COREINIT, MCP_GetTitleInfoByTitleAndDevice );
WUPS_MUST_REPLACE(ACPCheckTitleLaunchByTitleListTypeEx, WUPS_LOADER_LIBRARY_NN_ACP, ACPCheckTitleLaunchByTitleListTypeEx );
WUPS_MUST_REPLACE(ACPGetTitleMetaXmlByDevice, WUPS_LOADER_LIBRARY_NN_ACP, ACPGetTitleMetaXmlByDevice );
WUPS_MUST_REPLACE(ACPGetLaunchMetaXml, WUPS_LOADER_LIBRARY_NN_ACP, ACPGetLaunchMetaXml );
WUPS_MUST_REPLACE(ACPGetTitleMetaDirByDevice, WUPS_LOADER_LIBRARY_NN_ACP, ACPGetTitleMetaDirByDevice );
WUPS_MUST_REPLACE(_SYSLaunchTitleByPathFromLauncher, WUPS_LOADER_LIBRARY_SYSAPP, _SYSLaunchTitleByPathFromLauncher);
Reference in New Issue View Git Blame Copy Permalink