taihen.h

#ifndef TAI_HEADER
#define TAI_HEADER

#ifdef __cplusplus
extern "C" {
#endif

#include <psp2kern/types.h>
#include <stdint.h>

#define KERNEL_PID 0x10005

#define TAI_ANY_LIBRARY 0xFFFFFFFF

#define TAI_IGNORE_MODULE_NID 0xFFFFFFFF

#define TAI_MAIN_MODULE ((void *)0)

#define HELPER inline static __attribute__((unused))

typedef struct _tai_module_info {
  size_t size;                
  SceUID modid;               
  uint32_t module_nid;        
  char name[27];              
  uintptr_t exports_start;    
  uintptr_t exports_end;      
  uintptr_t imports_start;    
  uintptr_t imports_end;      
} tai_module_info_t;

typedef struct _tai_hook_args {
  size_t size;
  const char *module;
  uint32_t library_nid;
  uint32_t func_nid;
  const void *hook_func;
} tai_hook_args_t;

typedef struct _tai_offset_args {
  size_t size;
  SceUID modid;
  int segidx;
  uint32_t offset;
  int thumb;
  const void *source;
  size_t source_size;
} tai_offset_args_t;

typedef struct _tai_module_args {
  size_t size;
  SceUID pid;
  size_t args;
  void *argp;
  int flags;
} tai_module_args_t;

typedef uintptr_t tai_hook_ref_t;

struct _tai_hook_user {
  uintptr_t next;
  void *func;
  void *old;
};

SceUID taiHookFunctionAbs(SceUID pid, tai_hook_ref_t *p_hook, void *dest_func, const void *hook_func);
SceUID taiHookFunctionExportForKernel(SceUID pid, tai_hook_ref_t *p_hook, const char *module, uint32_t library_nid, uint32_t func_nid, const void *hook_func);
SceUID taiHookFunctionImportForKernel(SceUID pid, tai_hook_ref_t *p_hook, const char *module, uint32_t import_library_nid, uint32_t import_func_nid, const void *hook_func);
SceUID taiHookFunctionOffsetForKernel(SceUID pid, tai_hook_ref_t *p_hook, SceUID modid, int segidx, uint32_t offset, int thumb, const void *hook_func);
int taiGetModuleInfoForKernel(SceUID pid, const char *module, tai_module_info_t *info);
int taiHookReleaseForKernel(SceUID tai_uid, tai_hook_ref_t hook);
SceUID taiHookFunctionExportForUser(tai_hook_ref_t *p_hook, tai_hook_args_t *args);
SceUID taiHookFunctionImportForUser(tai_hook_ref_t *p_hook, tai_hook_args_t *args);
SceUID taiHookFunctionOffsetForUser(tai_hook_ref_t *p_hook, tai_offset_args_t *args);
int taiGetModuleInfo(const char *module, tai_module_info_t *info);
int taiHookRelease(SceUID tai_uid, tai_hook_ref_t hook);

HELPER SceUID taiHookFunctionExport(tai_hook_ref_t *p_hook, const char *module, uint32_t library_nid, uint32_t func_nid, const void *hook_func) {
  tai_hook_args_t args;
  args.size = sizeof(args);
  args.module = module;
  args.library_nid = library_nid;
  args.func_nid = func_nid;
  args.hook_func = hook_func;
  return taiHookFunctionExportForUser(p_hook, &args);
}

HELPER SceUID taiHookFunctionImport(tai_hook_ref_t *p_hook, const char *module, uint32_t import_library_nid, uint32_t import_func_nid, const void *hook_func) {
  tai_hook_args_t args;
  args.size = sizeof(args);
  args.module = module;
  args.library_nid = import_library_nid;
  args.func_nid = import_func_nid;
  args.hook_func = hook_func;
  return taiHookFunctionImportForUser(p_hook, &args);
}

HELPER SceUID taiHookFunctionOffset(tai_hook_ref_t *p_hook, SceUID modid, int segidx, uint32_t offset, int thumb, const void *hook_func) {
  tai_offset_args_t args;
  args.size = sizeof(args);
  args.modid = modid;
  args.segidx = segidx;
  args.offset = offset;
  args.thumb = thumb;
  args.source = hook_func;
  return taiHookFunctionOffsetForUser(p_hook, &args);
}
#ifdef __GNUC__

#define TAI_CONTINUE(type, hook, ...) ({ \
  struct _tai_hook_user *cur, *next; \
  cur = (struct _tai_hook_user *)(hook); \
  next = (struct _tai_hook_user *)cur->next; \
  (next == NULL) ? \
    ((type(*)())cur->old)(__VA_ARGS__) \
  : \
    ((type(*)())next->func)(__VA_ARGS__) \
  ; \
})
#else // __GNUC__
#error Non-GCC compatible compilers are currently unsupported
#endif // __GNUC__

SceUID taiInjectAbsForKernel(SceUID pid, void *dest, const void *src, size_t size);
SceUID taiInjectDataForKernel(SceUID pid, SceUID modid, int segidx, uint32_t offset, const void *data, size_t size);
int taiInjectReleaseForKernel(SceUID tai_uid);
SceUID taiInjectAbs(void *dest, const void *src, size_t size);
SceUID taiInjectDataForUser(tai_offset_args_t *args);
int taiInjectRelease(SceUID tai_uid);

HELPER SceUID taiInjectData(SceUID modid, int segidx, uint32_t offset, const void *data, size_t size) {
  tai_offset_args_t args;
  args.size = sizeof(args);
  args.modid = modid;
  args.segidx = segidx;
  args.offset = offset;
  args.source_size = size;
  args.source = data;
  return taiInjectDataForUser(&args);
}
int taiLoadPluginsForTitleForKernel(SceUID pid, const char *titleid, int flags);
SceUID taiLoadKernelModule(const char *path, int flags, void *opt);
int taiStartKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res);
SceUID taiLoadStartKernelModuleForUser(const char *path, tai_module_args_t *args);
SceUID taiLoadStartModuleForPidForUser(const char *path, tai_module_args_t *args);
int taiStopKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res);
int taiUnloadKernelModule(SceUID modid, int flags, void *opt);
int taiStopUnloadKernelModuleForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res);
int taiStopModuleForPidForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res);
int taiUnloadModuleForPid(SceUID pid, SceUID modid, int flags, void *opt);
int taiStopUnloadModuleForPidForUser(SceUID modid, tai_module_args_t *args, void *opt, int *res);

HELPER int taiStartKernelModule(SceUID modid, int args, void *argp, int flags, void *opt, int *res) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiStartKernelModuleForUser(modid, &argg, opt, res);
}

HELPER SceUID taiLoadStartKernelModule(const char *path, int args, void *argp, int flags) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiLoadStartKernelModuleForUser(path, &argg);
}

HELPER SceUID taiLoadStartModuleForPid(SceUID pid, const char *path, int args, void *argp, int flags) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.pid = pid;
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiLoadStartModuleForPidForUser(path, &argg);
}

HELPER int taiStopKernelModule(SceUID modid, int args, void *argp, int flags, void *opt, int *res) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiStopKernelModuleForUser(modid, &argg, opt, res);
}

HELPER int taiStopUnloadKernelModule(SceUID modid, int args, void *argp, int flags, void *opt, int *res) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiStopUnloadKernelModuleForUser(modid, &argg, opt, res);
}

HELPER int taiStopModuleForPid(SceUID pid, SceUID modid, int args, void *argp, int flags, void *opt, int *res) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.pid = pid;
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiStopModuleForPidForUser(modid, &argg, opt, res);
}

HELPER int taiStopUnloadModuleForPid(SceUID pid, SceUID modid, int args, void *argp, int flags, void *opt, int *res) {
  tai_module_args_t argg;
  argg.size = sizeof(argg);
  argg.pid = pid;
  argg.args = args;
  argg.argp = argp;
  argg.flags = flags;
  return taiStopUnloadModuleForPidForUser(modid, &argg, opt, res);
}

int taiMemcpyUserToKernel(void *kernel_dst, const void *user_src, size_t len);
int taiMemcpyKernelToUser(void *user_dst, const void *kernel_src, size_t len);

#ifdef __cplusplus
}
#endif

#endif // TAI_HEADER