The-Homebrew-Cloud/WiiUPluginSystem
2
0
Fork 0
mirror of https://github.com/wiiu-env/WiiUPluginSystem.git synced 2025-01-11 17:19:06 +01:00
Code Issues Packages Projects Releases Wiki Activity

Replaced all instances of the word "module" with "plugin"

Browse Source
This commit is contained in:
Maschell 2018-02-18 16:10:27 +01:00
parent d0908e7eb6
commit 41da4db58c
19 changed files with 194 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
loader/Makefile
View File

@ -37,9 +37,9 @@ SOURCES := src/common \
src/libelf \
src/menu/content \
src/menu \
src/modules \
src/myutils \
src/patcher \
src/plugin \
src/resources \
src/settings \
src/

32
loader/src/main.cpp
View File

@ -30,8 +30,8 @@
#include "common/retain_vars.h"
#include "common/common.h"
#include "modules/ModuleLoader.h"
#include "modules/ModuleData.h"
#include "plugin/PluginLoader.h"
#include "plugin/PluginInformation.h"
#include <utils/function_patcher.h>
@ -89,9 +89,9 @@ extern "C" int Menu_Main(int argc, char **argv){
if(isFirstBoot){
memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data));
ModuleLoader * moduleLoader = ModuleLoader::getInstance();
std::vector<ModuleInformation *> moduleList = moduleLoader->getModuleInformation("sd:/wiiu/plugins/");
moduleLoader->loadAndLinkModules(moduleList);
PluginLoader * pluginLoader = PluginLoader::getInstance();
std::vector<PluginInformation *> pluginList = pluginLoader->getPluginInformation("sd:/wiiu/plugins/");
pluginLoader->loadAndLinkPlugins(pluginList);
//!*******************************************************************
//! Initialize heap memory *
@ -149,18 +149,18 @@ extern "C" int Menu_Main(int argc, char **argv){
void ApplyPatches(){
PatchInvidualMethodHooks(method_hooks_hooks, method_hooks_size_hooks, method_calls_hooks);
for(int module_index=0;module_index<gbl_replacement_data.number_used_modules;module_index++){
new_PatchInvidualMethodHooks(&gbl_replacement_data.module_data[module_index]);
for(int plugin_index=0;plugin_index<gbl_replacement_data.number_used_plugins;plugin_index++){
new_PatchInvidualMethodHooks(&gbl_replacement_data.plugin_data[plugin_index]);
}
}
void CallHook(wups_loader_hook_type_t hook_type){
for(int module_index=0;module_index<gbl_replacement_data.number_used_modules;module_index++){
replacement_data_module_t * module_data = &gbl_replacement_data.module_data[module_index];
DEBUG_FUNCTION_LINE("Checking hook functions for %s.\n",module_data->module_name);
DEBUG_FUNCTION_LINE("Found hooks: %d\n",module_data->number_used_hooks);
for(int j=0;j<module_data->number_used_hooks;j++){
replacement_data_hook_t * hook_data = &module_data->hooks[j];
for(int plugin_index=0;plugin_index<gbl_replacement_data.number_used_plugins;plugin_index++){
replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
DEBUG_FUNCTION_LINE("Checking hook functions for %s.\n",plugin_data->plugin_name);
DEBUG_FUNCTION_LINE("Found hooks: %d\n",plugin_data->number_used_hooks);
for(int j=0;j<plugin_data->number_used_hooks;j++){
replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
if(hook_data->type == hook_type){
DEBUG_FUNCTION_LINE("Calling hook of type %d\n",hook_data->type);
void * func_ptr = hook_data->func_pointer;
@ -198,9 +198,9 @@ void DeInit(){
}
void RestorePatches(){
for(int module_index=gbl_replacement_data.number_used_modules-1;module_index>=0;module_index--){
DEBUG_FUNCTION_LINE("Restoring function for module: %d\n",module_index);
new_RestoreInvidualInstructions(&gbl_replacement_data.module_data[module_index]);
for(int plugin_index=gbl_replacement_data.number_used_plugins-1;plugin_index>=0;plugin_index--){
DEBUG_FUNCTION_LINE("Restoring function for plugin: %d\n",plugin_index);
new_RestoreInvidualInstructions(&gbl_replacement_data.plugin_data[plugin_index]);
}
RestoreInvidualInstructions(method_hooks_hooks, method_hooks_size_hooks);
}

14
loader/src/patcher/function_patcher.cpp
View File

@ -99,20 +99,20 @@ rpl_handling rpl_handles[] __attribute__((section(".data"))) = {
{WUPS_LOADER_LIBRARY_ZLIB125, "zlib125.rpl" ,0}
};
void new_PatchInvidualMethodHooks(replacement_data_module_t * module_data){
void new_PatchInvidualMethodHooks(replacement_data_plugin_t * plugin_data){
InitAcquireOS();
new_resetLibs();
DEBUG_FUNCTION_LINE("Patching %d given functions\n",module_data->number_used_functions);
DEBUG_FUNCTION_LINE("Patching %d given functions\n",plugin_data->number_used_functions);
s32 method_hooks_count = module_data->number_used_functions;
s32 method_hooks_count = plugin_data->number_used_functions;
u32 skip_instr = 1;
u32 my_instr_len = 6;
u32 instr_len = my_instr_len + skip_instr;
u32 flush_len = 4*instr_len;
for(s32 i = 0; i < method_hooks_count; i++){
replacement_data_function_t * function_data = &module_data->functions[i];
replacement_data_function_t * function_data = &plugin_data->functions[i];
/* Patch branches to it. */
volatile u32 *space = function_data->replace_data;
@ -209,15 +209,15 @@ void new_PatchInvidualMethodHooks(replacement_data_module_t * module_data){
/* ****************************************************************** */
/* RESTORE ORIGINAL INSTRUCTIONS */
/* ****************************************************************** */
void new_RestoreInvidualInstructions(replacement_data_module_t * module_data){
void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data){
InitAcquireOS();
new_resetLibs();
DEBUG_FUNCTION_LINE("Restoring given functions!\n");
s32 method_hooks_count = module_data->number_used_functions;
s32 method_hooks_count = plugin_data->number_used_functions;
for(s32 i = 0; i < method_hooks_count; i++){
replacement_data_function_t * function_data = &module_data->functions[i];
replacement_data_function_t * function_data = &plugin_data->functions[i];
DEBUG_FUNCTION_LINE("Restoring %s... ",function_data->function_name);
if(function_data->restoreInstruction == 0 || function_data->realAddr == 0){

30
loader/src/patcher/function_patcher.h
View File

@ -38,7 +38,7 @@ struct rpl_handling {
#define DYNAMIC_FUNCTION 1
#define FUNCTION_PATCHER_METHOD_STORE_SIZE 7
#define MAXIMUM_MODULE_NAME_LENGTH 51
#define MAXIMUM_PLUGIN_NAME_LENGTH 51
#define MAXIMUM_FUNCTION_NAME_LENGTH 51
struct replacement_data_function_t{
@ -62,28 +62,28 @@ struct replacement_data_hook_t{
};
#define MAXIMUM_HOOKS_PER_MODULE 10
#define MAXIMUM_FUNCTION_PER_MODULE 100
#define MAXIMUM_HOOKS_PER_PLUGIN 10
#define MAXIMUM_FUNCTION_PER_PLUGIN 100
struct replacement_data_module_t{
char module_name[MAXIMUM_MODULE_NAME_LENGTH] = ""; // Name of this module
int priority; // Priority of this module
int number_used_functions; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_MODULE
replacement_data_function_t functions[MAXIMUM_FUNCTION_PER_MODULE]; // Replacement information for each function.
struct replacement_data_plugin_t{
char plugin_name[MAXIMUM_PLUGIN_NAME_LENGTH] = ""; // Name of this plugin
int priority; // Priority of this plugin
int number_used_functions; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
replacement_data_function_t functions[MAXIMUM_FUNCTION_PER_PLUGIN]; // Replacement information for each function.
int number_used_hooks; // Number of used hooks. Maximum is MAXIMUM_HOOKS_PER_MODULE
replacement_data_hook_t hooks[MAXIMUM_HOOKS_PER_MODULE]; // Replacement information for each function.
int number_used_hooks; // Number of used hooks. Maximum is MAXIMUM_HOOKS_PER_PLUGIN
replacement_data_hook_t hooks[MAXIMUM_HOOKS_PER_PLUGIN]; // Replacement information for each function.
};
#define MAXIMUM_MODULES 32
#define MAXIMUM_PLUGINS 32
struct replacement_data_t{
int number_used_modules = 0; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_MODULE
replacement_data_module_t module_data[MAXIMUM_MODULES];
int number_used_plugins = 0; // Number of used function. Maximum is MAXIMUM_FUNCTION_PER_PLUGIN
replacement_data_plugin_t plugin_data[MAXIMUM_PLUGINS];
};
void new_PatchInvidualMethodHooks(replacement_data_module_t * data);
void new_RestoreInvidualInstructions(replacement_data_module_t * module_data);
void new_PatchInvidualMethodHooks(replacement_data_plugin_t * data);
void new_RestoreInvidualInstructions(replacement_data_plugin_t * plugin_data);
u32 new_GetAddressOfFunction(const char * functionName,wups_loader_library_type_t library);
s32 new_isDynamicFunction(u32 physicalAddress);
void new_resetLibs();

6
loader/src/modules/ElfTools.cpp → loader/src/plugin/ElfTools.cpp
View File

@ -175,7 +175,7 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
sizeof(module_unresolved_relocation_t), 1,
&module_relocations_capacity,
&module_relocations_count,
MODULE_RELOCATIONS_CAPCITY_DEFAULT);
PLUGIN_RELOCATIONS_CAPCITY_DEFAULT);
if (reloc == NULL)
return false;
@ -262,7 +262,7 @@ bool ElfTools::elfLink(Elf *elf, size_t shndx, void *destination, Elf32_Sym *sym
sizeof(module_unresolved_relocation_t), 1,
&module_relocations_capacity,
&module_relocations_count,
MODULE_RELOCATIONS_CAPCITY_DEFAULT);
PLUGIN_RELOCATIONS_CAPCITY_DEFAULT);
if (reloc == NULL)
return false;
@ -422,7 +422,7 @@ bool ElfTools::elfLinkOne(char type, size_t offset, int addend, void *destinatio
result = true;
exit_error:
if (!result) DEBUG_FUNCTION_LINE("Module_ElfLinkOne: exit_error\n");
if (!result) DEBUG_FUNCTION_LINE("Plugin_ElfLinkOne: exit_error\n");
return result;
}

0
loader/src/modules/ElfTools.h → loader/src/plugin/ElfTools.h
View File

0
loader/src/modules/EntryData.h → loader/src/plugin/EntryData.h
View File

0
loader/src/modules/HookData.h → loader/src/plugin/HookData.h
View File

20
loader/src/modules/ModuleData.h → loader/src/plugin/PluginData.h
View File

@ -15,14 +15,14 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/
#ifndef _MODULE_DATA_H_
#define _MODULE_DATA_H_
#ifndef _PLUGIN_DATA_H_
#define _PLUGIN_DATA_H_
#include <string>
#include <vector>
#include "EntryData.h"
#include "HookData.h"
#include "ModuleInformation.h"
#include "PluginInformation.h"
#include <utils/logger.h>
#ifdef __cplusplus
@ -35,13 +35,13 @@ extern "C" {
}
#endif
class ModuleData{
class PluginData{
public:
ModuleData(ModuleInformation * moduleInformation){
this->moduleInformation = moduleInformation;
PluginData(PluginInformation * pluginInformation){
this->pluginInformation = pluginInformation;
}
~ModuleData(){
~PluginData(){
for(size_t i = 0;i< entry_data_list.size();i++){
if(entry_data_list[i] != NULL){
delete entry_data_list[i];
@ -71,13 +71,13 @@ class ModuleData{
return hook_data_list;
}
ModuleInformation * getModuleInformation(){
return moduleInformation;
PluginInformation * getPluginInformation(){
return pluginInformation;
}
private:
ModuleInformation * moduleInformation;
PluginInformation * pluginInformation;
std::vector<EntryData *> entry_data_list;
std::vector<HookData *> hook_data_list;

34
loader/src/modules/ModuleInformation.cpp → loader/src/plugin/PluginInformation.cpp
View File

@ -1,4 +1,4 @@
/* based on module.c
/* based on plugin.c
* by Alex Chadwick
*
* Copyright (C) 2014, Alex Chadwick
@ -23,7 +23,7 @@
* SOFTWARE.
*/
#include "ModuleInformation.h"
#include "PluginInformation.h"
#include <utils/logger.h>
#include <dynamic_libs/os_types.h>
#include <libelf.h>
@ -36,7 +36,7 @@
#include <utils/utils.h>
#include "ElfTools.h"
bool ModuleInformation::checkFileExtenstion(const char * path) {
bool PluginInformation::checkFileExtenstion(const char * path) {
if(path == NULL){
return false;
}
@ -63,7 +63,7 @@ bool ModuleInformation::checkFileExtenstion(const char * path) {
return false;
}
bool ModuleInformation::openAndParseElf() {
bool PluginInformation::openAndParseElf() {
bool result = false;
int fd = -1;
Elf *elf = NULL;
@ -110,7 +110,7 @@ exit_error:
return result;
}
bool ModuleInformation::parseElf( Elf *elf) {
bool PluginInformation::parseElf( Elf *elf) {
bool res = false;
Elf_Scn *scn;
Elf32_Ehdr *ehdr;
@ -237,7 +237,7 @@ exit_error:
return res;
}
bool ModuleInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx) {
bool PluginInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_count, size_t symtab_strndx) {
char *metadata = NULL, *metadata_cur, *metadata_end;
const char *game, *name, *author, *version, *license, *wups;
@ -296,7 +296,7 @@ bool ModuleInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_
}
if (metadata == NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not a WUPS module file.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Not a WUPS plugin file.\n", path);
goto exit_error;
}
@ -326,37 +326,37 @@ bool ModuleInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_
if (strncmp(metadata_cur, "game", eq - metadata_cur) == 0) {
if (game != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_GAME declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_GAME declarations.\n", path);
goto exit_error;
}
game = eq + 1;
} else if (strncmp(metadata_cur, "name", eq - metadata_cur) == 0) {
if (name != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_NAME declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_NAME declarations.\n", path);
goto exit_error;
}
name = eq + 1;
} else if (strncmp(metadata_cur, "author", eq - metadata_cur) == 0) {
if (author != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_AUTHOR declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_AUTHOR declarations.\n", path);
goto exit_error;
}
author = eq + 1;
} else if (strncmp(metadata_cur, "version", eq - metadata_cur) == 0) {
if (version != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_VERSION declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_VERSION declarations.\n", path);
goto exit_error;
}
version = eq + 1;
} else if (strncmp(metadata_cur, "license", eq - metadata_cur) == 0) {
if (license != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_LICENSE declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_LICENSE declarations.\n", path);
goto exit_error;
}
license = eq + 1;
} else if (strncmp(metadata_cur, "wups", eq - metadata_cur) == 0) {
if (wups != NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_MODULE_NAME declarations.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Multiple WUPS_PLUGIN_NAME declarations.\n", path);
goto exit_error;
}
wups = eq + 1;
@ -372,19 +372,19 @@ bool ModuleInformation::metadataRead(Elf *elf, Elf32_Sym *symtab, size_t symtab_
goto exit_error;
}*/
if (name == NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_MODULE_NAME declaration.\n",path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_NAME declaration.\n",path);
goto exit_error;
}
if (author == NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_MODULE_AUTHOR declaration.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_AUTHOR declaration.\n", path);
goto exit_error;
}
if (version == NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_MODULE_VERSION declaration.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_VERSION declaration.\n", path);
goto exit_error;
}
if (license == NULL) {
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_MODULE_LICENSE declaration.\n", path);
DEBUG_FUNCTION_LINE("Warning: Ignoring '%s' - Missing WUPS_PLUGIN_LICENSE declaration.\n", path);
goto exit_error;
}

24
loader/src/modules/ModuleInformation.h → loader/src/plugin/PluginInformation.h
View File

@ -23,8 +23,8 @@
* SOFTWARE.
*/
#ifndef _MODULE_INFORMATION_H_
#define _MODULE_INFORMATION_H_
#ifndef _PLUGIN_INFORMATION_H_
#define _PLUGIN_INFORMATION_H_
#include <string>
#include <vector>
@ -42,20 +42,20 @@ extern "C" {
}
#endif
class ModuleInformation{
class PluginInformation{
public:
/**
returns ModuleInformation* if a valid plugin was found at the given path. Otherwise returns NULL
returns PluginInformation* if a valid plugin was found at the given path. Otherwise returns NULL
**/
static ModuleInformation * loadModuleInformation(std::string path){
if(ModuleInformation::checkFileExtenstion(path.c_str())){
DEBUG_FUNCTION_LINE("Checkfile successfully, loading now Module Information\n");
ModuleInformation * moduleInformation = new ModuleInformation(path);
if(moduleInformation->openAndParseElf()){
return moduleInformation;
static PluginInformation * loadPluginInformation(std::string path){
if(PluginInformation::checkFileExtenstion(path.c_str())){
DEBUG_FUNCTION_LINE("Checkfile successfully, loading now Plugin Information\n");
PluginInformation * pluginInformation = new PluginInformation(path);
if(pluginInformation->openAndParseElf()){
return pluginInformation;
}else{
delete moduleInformation;
delete pluginInformation;
return NULL;
}
} else {
@ -87,7 +87,7 @@ class ModuleInformation{
return this->size;
}
private:
ModuleInformation(std::string path){
PluginInformation(std::string path){
this->path = path;
}

128
loader/src/modules/ModuleLoader.cpp → loader/src/plugin/PluginLoader.cpp
View File

@ -29,15 +29,15 @@
#include <fcntl.h>
#include <unistd.h>
#include "ElfTools.h"
#include "ModuleData.h"
#include "ModuleLoader.h"
#include "PluginData.h"
#include "PluginLoader.h"
#include "utils/StringTools.h"
#include "common/retain_vars.h"
ModuleLoader * ModuleLoader::instance = NULL;
PluginLoader * PluginLoader::instance = NULL;
std::vector<ModuleInformation *> ModuleLoader::getModuleInformation(const char * path){
std::vector<ModuleInformation *> result;
std::vector<PluginInformation *> PluginLoader::getPluginInformation(const char * path){
std::vector<PluginInformation *> result;
struct dirent *dp;
DIR *dfd = NULL;
@ -64,10 +64,10 @@ std::vector<ModuleInformation *> ModuleLoader::getModuleInformation(const char *
continue;
}else{
DEBUG_FUNCTION_LINE("Found file: %s\n",full_file_path.c_str()) ;
ModuleInformation * module = ModuleInformation::loadModuleInformation(full_file_path);
if(module != NULL){
DEBUG_FUNCTION_LINE("Found plugin %s by %s. Size: %d kb \n",module->getName().c_str(),module->getAuthor().c_str(),module->getSize()/1024) ;
result.push_back(module);
PluginInformation * plugin = PluginInformation::loadPluginInformation(full_file_path);
if(plugin != NULL){
DEBUG_FUNCTION_LINE("Found plugin %s by %s. Size: %d kb \n",plugin->getName().c_str(),plugin->getAuthor().c_str(),plugin->getSize()/1024) ;
result.push_back(plugin);
} else {
DEBUG_FUNCTION_LINE("%s is not a valid plugin\n",full_file_path.c_str()) ;
}
@ -77,46 +77,46 @@ std::vector<ModuleInformation *> ModuleLoader::getModuleInformation(const char *
return result;
}
void ModuleLoader::loadAndLinkModules(std::vector<ModuleInformation *> moduleInformation){
std::vector<ModuleData *> loadedModules;
for(size_t i = 0;i < moduleInformation.size(); i++){
DEBUG_FUNCTION_LINE("loadAndLinkModules for %d\n",i) ;
ModuleInformation * cur_info = moduleInformation[i];
ModuleData * moduleData = loadAndLinkModule(cur_info);
if(moduleData == NULL){
DEBUG_FUNCTION_LINE("loadAndLinkModules failed for %d\n",i) ;
void PluginLoader::loadAndLinkPlugins(std::vector<PluginInformation *> pluginInformation){
std::vector<PluginData *> loadedPlugins;
for(size_t i = 0;i < pluginInformation.size(); i++){
DEBUG_FUNCTION_LINE("loadAndLinkPlugins for %d\n",i) ;
PluginInformation * cur_info = pluginInformation[i];
PluginData * pluginData = loadAndLinkPlugin(cur_info);
if(pluginData == NULL){
DEBUG_FUNCTION_LINE("loadAndLinkPlugins failed for %d\n",i) ;
continue;
} else {
loadedModules.push_back(moduleData);
loadedPlugins.push_back(pluginData);
}
}
copyModuleDataIntoGlobalStruct(loadedModules);
clearModuleData(loadedModules);
copyPluginDataIntoGlobalStruct(loadedPlugins);
clearPluginData(loadedPlugins);
}
void ModuleLoader::clearModuleData(std::vector<ModuleData *> moduleData){
for(size_t i = 0;i < moduleData.size(); i++){
ModuleData * curModuleData = moduleData[i];
if(curModuleData != NULL){
delete curModuleData;
void PluginLoader::clearPluginData(std::vector<PluginData *> pluginData){
for(size_t i = 0;i < pluginData.size(); i++){
PluginData * curPluginData = pluginData[i];
if(curPluginData != NULL){
delete curPluginData;
}
}
}
ModuleData * ModuleLoader::loadAndLinkModule(ModuleInformation * moduleInformation){
PluginData * PluginLoader::loadAndLinkPlugin(PluginInformation * pluginInformation){
DEBUG_FUNCTION_LINE("\n");
ModuleData * result = NULL;
PluginData * result = NULL;
int fd = -1;
Elf *elf = NULL;
if(moduleInformation == NULL){
DEBUG_FUNCTION_LINE("moduleInformation was NULL\n");
if(pluginInformation == NULL){
DEBUG_FUNCTION_LINE("pluginInformation was NULL\n");
goto exit_error;
}
if(moduleInformation->getSize() > ((u32) this->getCurrentStoreAddress() - (u32) this->startAddress)){
if(pluginInformation->getSize() > ((u32) this->getCurrentStoreAddress() - (u32) this->startAddress)){
DEBUG_FUNCTION_LINE("Not enough space left to loader the plugin into memory\n");
goto exit_error;
}
@ -126,10 +126,10 @@ ModuleData * ModuleLoader::loadAndLinkModule(ModuleInformation * moduleInformati
goto exit_error;
}
fd = open(moduleInformation->getPath().c_str(), O_RDONLY, 0);
fd = open(pluginInformation->getPath().c_str(), O_RDONLY, 0);
if (fd == -1){
DEBUG_FUNCTION_LINE("failed to open '%s' \n", moduleInformation->getPath().c_str());
DEBUG_FUNCTION_LINE("failed to open '%s' \n", pluginInformation->getPath().c_str());
goto exit_error;
}
@ -141,7 +141,7 @@ ModuleData * ModuleLoader::loadAndLinkModule(ModuleInformation * moduleInformati
}
DEBUG_FUNCTION_LINE("\n");
result = new ModuleData(moduleInformation);
result = new PluginData(pluginInformation);
if(result == NULL){
DEBUG_FUNCTION_LINE("Failed to create object\n");
goto exit_error;
@ -162,8 +162,8 @@ exit_error:
return result;
}
bool ModuleLoader::loadAndLinkElf(ModuleData * moduleData, Elf *elf, void * endAddress) {
if(moduleData == NULL || elf == NULL || endAddress == NULL){
bool PluginLoader::loadAndLinkElf(PluginData * pluginData, Elf *elf, void * endAddress) {
if(pluginData == NULL || elf == NULL || endAddress == NULL){
return false;
}
@ -317,16 +317,16 @@ bool ModuleLoader::loadAndLinkElf(ModuleData * moduleData, Elf *elf, void * endA
for(size_t j=0;j<hook_t_list.size();j++){
wups_loader_hook_t * hook = hook_t_list[j];
DEBUG_FUNCTION_LINE("Saving hook of module \"%s\". Type: %08X, target: %08X\n",moduleData->getModuleInformation()->getName().c_str(),hook->type,(void*) hook->target);
DEBUG_FUNCTION_LINE("Saving hook of plugin \"%s\". Type: %08X, target: %08X\n",pluginData->getPluginInformation()->getName().c_str(),hook->type,(void*) hook->target);
HookData * hook_data = new HookData((void *) hook->target,hook->type);
moduleData->addHookData(hook_data);
pluginData->addHookData(hook_data);
}
for(size_t j=0;j<entry_t_list.size();j++){
wups_loader_entry_t * entry = entry_t_list[j];
DEBUG_FUNCTION_LINE("Saving entry \"%s\" of module \"%s\". Library: %08X, target: %08X, call_addr: %08X\n",entry->_function.name,moduleData->getModuleInformation()->getName().c_str(),entry->_function.library,entry->_function.target, (void *) entry->_function.call_addr);
DEBUG_FUNCTION_LINE("Saving entry \"%s\" of plugin \"%s\". Library: %08X, target: %08X, call_addr: %08X\n",entry->_function.name,pluginData->getPluginInformation()->getName().c_str(),entry->_function.library,entry->_function.target, (void *) entry->_function.call_addr);
EntryData * entry_data = new EntryData(entry->_function.name,entry->_function.library, (void *) entry->_function.target, (void *) entry->_function.call_addr);
moduleData->addEntryData(entry_data);
pluginData->addEntryData(entry_data);
}
this->setCurrentStoreAddress((void *) curAddress);
@ -349,39 +349,39 @@ exit_error:
return result;
}
void ModuleLoader::copyModuleDataIntoGlobalStruct(std::vector<ModuleData *> modules){
void PluginLoader::copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plugins){
// Reset data
memset((void*)&gbl_replacement_data,0,sizeof(gbl_replacement_data));
int module_index = 0;
int plugin_index = 0;
// Copy data to global struct.
for(size_t i = 0; i< modules.size();i++){
ModuleData * cur_module = modules.at(i);
ModuleInformation * cur_moduleInformation = cur_module->getModuleInformation();
for(size_t i = 0; i< plugins.size();i++){
PluginData * cur_plugin = plugins.at(i);
PluginInformation * cur_pluginInformation = cur_plugin->getPluginInformation();
std::vector<EntryData *> entry_data_list = cur_module->getEntryDataList();
std::vector<HookData *> hook_data_list = cur_module->getHookDataList();
if(module_index >= MAXIMUM_MODULES ){
DEBUG_FUNCTION_LINE("Maximum of %d modules reached. %s won't be loaded!\n",MAXIMUM_MODULES,cur_moduleInformation->getName().c_str());
std::vector<EntryData *> entry_data_list = cur_plugin->getEntryDataList();
std::vector<HookData *> hook_data_list = cur_plugin->getHookDataList();
if(plugin_index >= MAXIMUM_PLUGINS ){
DEBUG_FUNCTION_LINE("Maximum of %d plugins reached. %s won't be loaded!\n",MAXIMUM_PLUGINS,cur_pluginInformation->getName().c_str());
continue;
}
if(entry_data_list.size() > MAXIMUM_FUNCTION_PER_MODULE){
DEBUG_FUNCTION_LINE("Module %s would replace to many function (%d, maximum is %d). It won't be loaded.\n",cur_moduleInformation->getName().c_str(),entry_data_list.size(),MAXIMUM_FUNCTION_PER_MODULE);
if(entry_data_list.size() > MAXIMUM_FUNCTION_PER_PLUGIN){
DEBUG_FUNCTION_LINE("Plugin %s would replace to many function (%d, maximum is %d). It won't be loaded.\n",cur_pluginInformation->getName().c_str(),entry_data_list.size(),MAXIMUM_FUNCTION_PER_PLUGIN);
continue;
}
if(hook_data_list.size() > MAXIMUM_HOOKS_PER_MODULE){
DEBUG_FUNCTION_LINE("Module %s would set too many hooks (%d, maximum is %d). It won't be loaded.\n",cur_moduleInformation->getName().c_str(),hook_data_list.size(),MAXIMUM_HOOKS_PER_MODULE);
if(hook_data_list.size() > MAXIMUM_HOOKS_PER_PLUGIN){
DEBUG_FUNCTION_LINE("Plugin %s would set too many hooks (%d, maximum is %d). It won't be loaded.\n",cur_pluginInformation->getName().c_str(),hook_data_list.size(),MAXIMUM_HOOKS_PER_PLUGIN);
continue;
}
replacement_data_module_t * module_data = &gbl_replacement_data.module_data[module_index];
replacement_data_plugin_t * plugin_data = &gbl_replacement_data.plugin_data[plugin_index];
strncpy(module_data->module_name,cur_moduleInformation->getName().c_str(),MAXIMUM_MODULE_NAME_LENGTH-1);
strncpy(plugin_data->plugin_name,cur_pluginInformation->getName().c_str(),MAXIMUM_PLUGIN_NAME_LENGTH-1);
for(size_t j = 0; j < entry_data_list.size();j++){
replacement_data_function_t * function_data = &module_data->functions[j];
replacement_data_function_t * function_data = &plugin_data->functions[j];
EntryData * cur_entry = entry_data_list[j];
DEBUG_FUNCTION_LINE("Adding entry \"%s\" for module \"%s\"\n",cur_entry->getName().c_str(),module_data->module_name);
DEBUG_FUNCTION_LINE("Adding entry \"%s\" for plugin \"%s\"\n",cur_entry->getName().c_str(),plugin_data->plugin_name);
//TODO: Warning/Error if string is too long.
strncpy(function_data->function_name,cur_entry->getName().c_str(),MAXIMUM_FUNCTION_NAME_LENGTH-1);
@ -390,25 +390,25 @@ void ModuleLoader::copyModuleDataIntoGlobalStruct(std::vector<ModuleData *> modu
function_data->replaceAddr = (u32) cur_entry->getReplaceAddress();
function_data->replaceCall = (u32) cur_entry->getReplaceCall();
module_data->number_used_functions++;
plugin_data->number_used_functions++;
}
DEBUG_FUNCTION_LINE("Entries for module \"%s\": %d\n",module_data->module_name,module_data->number_used_functions);
DEBUG_FUNCTION_LINE("Entries for plugin \"%s\": %d\n",plugin_data->plugin_name,plugin_data->number_used_functions);
for(size_t j = 0; j < hook_data_list.size();j++){
replacement_data_hook_t * hook_data = &module_data->hooks[j];
replacement_data_hook_t * hook_data = &plugin_data->hooks[j];
HookData * hook_entry = hook_data_list[j];
DEBUG_FUNCTION_LINE("Set hook for module \"%s\" of type %08X to target %08X\n",module_data->module_name,hook_entry->getType(),(void*) hook_entry->getFunctionPointer());
DEBUG_FUNCTION_LINE("Set hook for plugin \"%s\" of type %08X to target %08X\n",plugin_data->plugin_name,hook_entry->getType(),(void*) hook_entry->getFunctionPointer());
hook_data->func_pointer = (void*) hook_entry->getFunctionPointer();
hook_data->type = hook_entry->getType();
module_data->number_used_hooks++;
plugin_data->number_used_hooks++;
}
DEBUG_FUNCTION_LINE("Hooks for module \"%s\": %d\n",module_data->module_name,module_data->number_used_hooks);
DEBUG_FUNCTION_LINE("Hooks for plugin \"%s\": %d\n",plugin_data->plugin_name,plugin_data->number_used_hooks);
module_index++;
gbl_replacement_data.number_used_modules++;
plugin_index++;
gbl_replacement_data.number_used_plugins++;
}
}

50
loader/src/modules/ModuleLoader.h → loader/src/plugin/PluginLoader.h
View File

@ -23,12 +23,12 @@
* SOFTWARE.
*/
#ifndef _MODULE_LOADER_H_
#define _MODULE_LOADER_H_
#ifndef _PLUGIN_LOADER_H_
#define _PLUGIN_LOADER_H_
#include <vector>
#include "ModuleInformation.h"
#include "ModuleData.h"
#include "PluginInformation.h"
#include "PluginData.h"
#ifdef __cplusplus
extern "C" {
@ -43,12 +43,12 @@ extern "C" {
#define PLUGIN_LOCATION_END_ADDRESS 0x01000000
class ModuleLoader{
class PluginLoader{
public:
static ModuleLoader *getInstance() {
static PluginLoader *getInstance() {
if(!instance){
instance = new ModuleLoader((void*)getApplicationEndAddr(),(void *)PLUGIN_LOCATION_END_ADDRESS);
instance = new PluginLoader((void*)getApplicationEndAddr(),(void *)PLUGIN_LOCATION_END_ADDRESS);
}
return instance;
}
@ -65,9 +65,9 @@ public:
\param path the path of the directory which should be scanned.
\return a list of ModuleInformation objects, one for each valid plugin.
\return a list of PluginInformation objects, one for each valid plugin.
**/
std::vector<ModuleInformation *> getModuleInformation(const char * path);
std::vector<PluginInformation *> getPluginInformation(const char * path);
/**
\brief Gets plugin information from the global struct.
@ -75,64 +75,64 @@ public:
\return a list of MetaInformation objects for all plugins currently loaded and linked (relocated). Will only contain
plugin which are still on the sd card.
**/
//std::vector<ModuleInformation *> getModulesLoadedInMemory();
//std::vector<PluginInformation *> getPluginsLoadedInMemory();
/**
\brief Takes a list of modules that should be linked (relocated) loaded into the memory.
\brief Takes a list of plugins that should be linked (relocated) loaded into the memory.
The function that should be replaced will be replaced in the order of the given plugin list.
So two plugin will override the same function, the plugin first in this list will override the function first.
Also the hooks of the plugins will be called in the order their plugin where passed to this method.
\param A list of plugin that should be linked (relocated) an loaded into memory
**/
void loadAndLinkModules(std::vector<ModuleInformation *> moduleInformation);
void loadAndLinkPlugins(std::vector<PluginInformation *> pluginInformation);
private:
ModuleLoader(void * startAddress, void * endAddress){
PluginLoader(void * startAddress, void * endAddress){
// TODO: Check if endAddress > startAddress.
this->startAddress = startAddress;
this->endAddress = endAddress;
this->currentStoreAddress = endAddress;
}
~ModuleLoader(){
~PluginLoader(){
}
static ModuleLoader *instance;
static PluginLoader *instance;
/**
\brief Iterates through the vector and delete all it's elements
\param A list of ModuleData* that should be deleted.
\param A list of PluginData* that should be deleted.
**/
void clearModuleData(std::vector<ModuleData *> moduleData);
void clearPluginData(std::vector<PluginData *> pluginData);
/**
\brief Load
\param moduleInformation a ModuleInformation object of the plugin that should be linked (relocated) and loaded.
\param pluginInformation a PluginInformation object of the plugin that should be linked (relocated) and loaded.
\return NULL on error. On success it will return a ModuleData object.
\return NULL on error. On success it will return a PluginData object.
**/
ModuleData * loadAndLinkModule(ModuleInformation * moduleInformation);
PluginData * loadAndLinkPlugin(PluginInformation * pluginInformation);
/**
\brief Loads a plugin into memory (in the startAddress/endAddress range defined in this loader) and relocates it.
Modifies the moduleData param. Adds loaded functions and hooks.
\param moduleData object where the result should be stored
Modifies the pluginData param. Adds loaded functions and hooks.
\param pluginData object where the result should be stored
\param elf source elf from where the sections will be loaded
\param storeAddressEnd the address where the plugin data will be stored in memory. Saving BACKWARD.
**/
bool loadAndLinkElf(ModuleData * moduleData, Elf *elf, void * storeAddressEnd);
bool loadAndLinkElf(PluginData * pluginData, Elf *elf, void * storeAddressEnd);
/**
\brief Copies the needed information into a global, persistent struct. This struct holds information on which
function should be override in which order and which hook should be called.
\param modules list of modules that should be used.
\param plugins list of plugins that should be used.
**/
void copyModuleDataIntoGlobalStruct(std::vector<ModuleData *> modules);
void copyPluginDataIntoGlobalStruct(std::vector<PluginData *> plugins);
void * getCurrentStoreAddress(){
return this->currentStoreAddress;

8
plugins/example_plugin/src/main.cpp
View File

@ -6,10 +6,10 @@
#include "dynamic_libs/fs_functions.h"
#include "utils/logger.h"
WUPS_MODULE_NAME("test module");
WUPS_MODULE_VERSION("v1.0");
WUPS_MODULE_AUTHOR("Maschell");
WUPS_MODULE_LICENSE("BSD");
WUPS_PLUGIN_NAME("test PLUGIN");
WUPS_PLUGIN_VERSION("v1.0");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("BSD");
INITIALIZE(args){
InitOSFunctionPointers();

8
plugins/hid_to_vpad/src/main.cpp
View File

@ -9,10 +9,10 @@
#include <utils/logger.h>
#include <fs/sd_fat_devoptab.h>
WUPS_MODULE_NAME("HID to VPAD lite");
WUPS_MODULE_VERSION("v1.0");
WUPS_MODULE_AUTHOR("Maschell");
WUPS_MODULE_LICENSE("GPL");
WUPS_PLUGIN_NAME("HID to VPAD lite");
WUPS_PLUGIN_VERSION("v1.0");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("GPL");
#define SD_PATH "sd:"
#define WIIU_PATH "/wiiu"

8
plugins/padcon/src/main.c
View File

@ -5,10 +5,10 @@
#include "dynamic_libs/socket_functions.h"
#include "utils/logger.h"
WUPS_MODULE_NAME("Padcon");
WUPS_MODULE_VERSION("v1.0");
WUPS_MODULE_AUTHOR("Maschell");
WUPS_MODULE_LICENSE("GPL");
WUPS_PLUGIN_NAME("Padcon");
WUPS_PLUGIN_VERSION("v1.0");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("GPL");
INITIALIZE(args){

8
plugins/sdcafiine/src/main.cpp
View File

@ -14,10 +14,10 @@
#include "main.h"
#include "modpackSelector.h"
WUPS_MODULE_NAME("SDCaffiine lite");
WUPS_MODULE_VERSION("v1.0");
WUPS_MODULE_AUTHOR("Maschell");
WUPS_MODULE_LICENSE("GPL");
WUPS_PLUGIN_NAME("SDCaffiine lite");
WUPS_PLUGIN_VERSION("v1.0");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("GPL");
INITIALIZE(args){
WUPS_InitFS(args);

8
plugins/swipswapme/src/main.c
View File

@ -34,10 +34,10 @@
#include <utils/logger.h>
#include <common/c_retain_vars.h>
WUPS_MODULE_NAME("SwipSwapMe");
WUPS_MODULE_VERSION("v1.0");
WUPS_MODULE_AUTHOR("Maschell");
WUPS_MODULE_LICENSE("GPL");
WUPS_PLUGIN_NAME("SwipSwapMe");
WUPS_PLUGIN_VERSION("v1.0");
WUPS_PLUGIN_AUTHOR("Maschell");
WUPS_PLUGIN_LICENSE("GPL");
u8 isFirstBoot __attribute__((section(".data"))) = 1;

8
wups_include/wups.h
View File

@ -215,10 +215,10 @@ typedef struct wups_loader_entry_t {
extern const char wups_meta_ ## id [] WUPS_SECTION("meta"); \
const char wups_meta_ ## id [] = #id "=" value
#define WUPS_MODULE_NAME(x) WUPS_META(name, x); WUPS_META(wups, "0.1")
#define WUPS_MODULE_AUTHOR(x) WUPS_META(author, x)
#define WUPS_MODULE_VERSION(x) WUPS_META(version, x)
#define WUPS_MODULE_LICENSE(x) WUPS_META(license, x)
#define WUPS_PLUGIN_NAME(x) WUPS_META(name, x); WUPS_META(wups, "0.1")
#define WUPS_PLUGIN_AUTHOR(x) WUPS_META(author, x)
#define WUPS_PLUGIN_VERSION(x) WUPS_META(version, x)
#define WUPS_PLUGIN_LICENSE(x) WUPS_META(license, x)
void WUPS_InitFS(wups_loader_init_args_t* args);