Change directory structure

sysmodules/loader/source/CFWInfo.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <3ds/types.h>
+
+typedef struct __attribute__((packed))
+{
+    char magic[4];
+    
+    u8 versionMajor;
+    u8 versionMinor;
+    u8 versionBuild;
+    u8 flags;
+
+    u32 commitHash;
+
+    u32 config;
+} CFWInfo;
+
+u32 svcGetCFWInfo(CFWInfo *info);

sysmodules/loader/source/CFWInfo.s

@@ -0,0 +1,9 @@
+.text
+.arm
+.align 4
+
+.global svcGetCFWInfo
+.type	svcGetCFWInfo, %function
+svcGetCFWInfo:
+	svc 0x2e
+	bx lr

sysmodules/loader/source/exheader.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <3ds/types.h>
+
+typedef struct
+{
+	u8 reserved[5];
+	u8 flag;
+	u8 remasterversion[2];
+} PACKED exheader_systeminfoflags;
+
+typedef struct
+{
+	u32 address;
+	u32 nummaxpages;
+	u32 codesize;
+} PACKED exheader_codesegmentinfo;
+
+typedef struct
+{
+	u8 name[8];
+	exheader_systeminfoflags flags;
+	exheader_codesegmentinfo text;
+	u8 stacksize[4];
+	exheader_codesegmentinfo ro;
+	u8 reserved[4];
+	exheader_codesegmentinfo data;
+	u32 bsssize;
+} PACKED exheader_codesetinfo;
+
+typedef struct
+{
+	u64 programid[0x30];
+} PACKED exheader_dependencylist;
+
+typedef struct
+{
+	u8 savedatasize[4];
+	u8 reserved[4];
+	u8 jumpid[8];
+	u8 reserved2[0x30];
+} PACKED exheader_systeminfo;
+
+typedef struct
+{
+	u8 extsavedataid[8];
+	u8 systemsavedataid[8];
+	u8 reserved[8];
+	u8 accessinfo[7];
+	u8 otherattributes;
+} PACKED exheader_storageinfo;
+
+typedef struct
+{
+	u64 programid;
+	u8 flags[8];
+	u16 resourcelimitdescriptor[0x10];
+	exheader_storageinfo storageinfo;
+	u64 serviceaccesscontrol[0x20];
+	u8 reserved[0x1f];
+	u8 resourcelimitcategory;
+} PACKED exheader_arm11systemlocalcaps;
+
+typedef struct
+{
+	u32 descriptors[28];
+	u8 reserved[0x10];
+} PACKED exheader_arm11kernelcapabilities;
+
+typedef struct
+{
+	u8 descriptors[15];
+	u8 descversion;
+} PACKED exheader_arm9accesscontrol;
+
+typedef struct
+{
+	// systemcontrol info {
+	//   coreinfo {
+	exheader_codesetinfo codesetinfo;
+	exheader_dependencylist deplist;
+	//   }
+	exheader_systeminfo systeminfo;
+	// }
+	// accesscontrolinfo {
+	exheader_arm11systemlocalcaps arm11systemlocalcaps;
+	exheader_arm11kernelcapabilities arm11kernelcaps;
+	exheader_arm9accesscontrol arm9accesscontrol;
+	// }
+	struct {
+		u8 signature[0x100];
+		u8 ncchpubkeymodulus[0x100];
+		exheader_arm11systemlocalcaps arm11systemlocalcaps;
+		exheader_arm11kernelcapabilities arm11kernelcaps;
+		exheader_arm9accesscontrol arm9accesscontrol;
+	} PACKED accessdesc;
+} PACKED exheader_header;

sysmodules/loader/source/fsldr.c

@@ -0,0 +1,166 @@
+#include <3ds.h>
+#include "fsldr.h"
+#include "fsreg.h"
+#include "srvsys.h"
+
+#define SDK_VERSION 0x70200C8
+
+static Handle fsldrHandle;
+static int fsldrRefCount;
+
+// MAKE SURE fsreg has been init before calling this
+static Result fsldrPatchPermissions(void)
+{
+  u32 pid;
+  Result res;
+  FS_ProgramInfo info;
+  u32 storage[8] = {0};
+
+  storage[6] = 0x680; // SDMC access and NAND access flag
+  info.programId = 0x0004013000001302LL; // loader PID
+  info.mediaType = MEDIATYPE_NAND;
+  res = svcGetProcessId(&pid, 0xFFFF8001);
+  if (R_SUCCEEDED(res))
+  {
+    res = FSREG_Register(pid, 0xFFFF000000000000LL, &info, (u8 *)storage);
+  }
+  return res;
+}
+
+Result fsldrInit(void)
+{
+  Result ret = 0;
+
+  if (AtomicPostIncrement(&fsldrRefCount)) return 0;
+
+  ret = srvSysGetServiceHandle(&fsldrHandle, "fs:LDR");
+  if (R_SUCCEEDED(ret))
+  {
+    fsldrPatchPermissions();
+    ret = FSLDR_InitializeWithSdkVersion(fsldrHandle, SDK_VERSION);
+    ret = FSLDR_SetPriority(0);
+    if (R_FAILED(ret)) svcBreak(USERBREAK_ASSERT);
+  }
+  else
+  {
+    AtomicDecrement(&fsldrRefCount);
+  }
+
+  return ret;
+}
+
+void fsldrExit(void)
+{
+  if (AtomicDecrement(&fsldrRefCount)) return;
+  svcCloseHandle(fsldrHandle);
+}
+
+Result FSLDR_InitializeWithSdkVersion(Handle session, u32 version)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x861,1,2); // 0x8610042
+  cmdbuf[1] = version;
+  cmdbuf[2] = 32;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(session))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSLDR_SetPriority(u32 priority)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x862,1,0); // 0x8620040
+  cmdbuf[1] = priority;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsldrHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSLDR_OpenFileDirectly(Handle* out, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 openFlags, u32 attributes)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x803,8,4); // 0x8030204
+  cmdbuf[1] = 0;
+  cmdbuf[2] = archiveId;
+  cmdbuf[3] = archivePath.type;
+  cmdbuf[4] = archivePath.size;
+  cmdbuf[5] = filePath.type;
+  cmdbuf[6] = filePath.size;
+  cmdbuf[7] = openFlags;
+  cmdbuf[8] = attributes;
+  cmdbuf[9] = IPC_Desc_StaticBuffer(archivePath.size, 2);
+  cmdbuf[10] = (u32)archivePath.data;
+  cmdbuf[11] = IPC_Desc_StaticBuffer(filePath.size, 0);
+  cmdbuf[12] = (u32)filePath.data;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsldrHandle))) return ret;
+
+  if(out) *out = cmdbuf[3];
+
+  return cmdbuf[1];
+}
+
+Result FSLDR_OpenArchive(FS_Archive* archive, FS_ArchiveID id, FS_Path path)
+{
+  if(!archive) return -2;
+
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x80C,3,2); // 0x80C00C2
+  cmdbuf[1] = id;
+  cmdbuf[2] = path.type;
+  cmdbuf[3] = path.size;
+  cmdbuf[4] = IPC_Desc_StaticBuffer(path.size, 0);
+  cmdbuf[5] = (u32) path.data;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsldrHandle))) return ret;
+
+  if(archive) *archive = cmdbuf[2] | ((u64) cmdbuf[3] << 32);
+
+  return cmdbuf[1];
+}
+
+Result FSLDR_CloseArchive(FS_Archive archive)
+{
+  if(!archive) return -2;
+
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x80E,2,0); // 0x80E0080
+  cmdbuf[1] = (u32) archive;
+  cmdbuf[2] = (u32) (archive >> 32);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsldrHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSLDR_OpenDirectory(Handle* out, FS_Archive archive, FS_Path path)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x80B,4,2); // 0x80B0102
+  cmdbuf[1] = (u32) archive;
+  cmdbuf[2] = (u32) (archive >> 32);
+  cmdbuf[3] = path.type;
+  cmdbuf[4] = path.size;
+  cmdbuf[5] = IPC_Desc_StaticBuffer(path.size, 0);
+  cmdbuf[6] = (u32) path.data;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsldrHandle))) return ret;
+
+  if(out) *out = cmdbuf[3];
+
+  return cmdbuf[1];
+}

sysmodules/loader/source/fsldr.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <3ds/types.h>
+
+Result fsldrInit(void);
+void fsldrExit(void);
+Result FSLDR_InitializeWithSdkVersion(Handle session, u32 version);
+Result FSLDR_SetPriority(u32 priority);
+Result FSLDR_OpenFileDirectly(Handle* out, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 openFlags, u32 attributes);
+Result FSLDR_OpenArchive(FS_Archive* archive, FS_ArchiveID id, FS_Path path);
+Result FSLDR_CloseArchive(FS_Archive archive);
+Result FSLDR_OpenDirectory(Handle* out, FS_Archive archive, FS_Path path);

sysmodules/loader/source/fsreg.c

@@ -0,0 +1,116 @@
+#include <3ds.h>
+#include <string.h>
+#include "fsreg.h"
+#include "srvsys.h"
+
+static Handle fsregHandle;
+static int fsregRefCount;
+
+Result fsregInit(void)
+{
+  Result ret = 0;
+
+  if (AtomicPostIncrement(&fsregRefCount)) return 0;
+
+  ret = srvSysGetServiceHandle(&fsregHandle, "fs:REG");
+
+  if (R_FAILED(ret)) AtomicDecrement(&fsregRefCount);
+  return ret;
+}
+
+void fsregExit(void)
+{
+  if (AtomicDecrement(&fsregRefCount)) return;
+  svcCloseHandle(fsregHandle);
+}
+
+Result FSREG_CheckHostLoadId(u64 prog_handle)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x406,2,0); // 0x4060080
+  cmdbuf[1] = (u32) (prog_handle);
+  cmdbuf[2] = (u32) (prog_handle >> 32);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSREG_LoadProgram(u64 *prog_handle, FS_ProgramInfo *title)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x404,4,0); // 0x4040100
+  memcpy(&cmdbuf[1], &title->programId, sizeof(u64));
+  *(u8 *)&cmdbuf[3] = title->mediaType;
+  memcpy(((u8 *)&cmdbuf[3])+1, &title->padding, 7);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+  *prog_handle = *(u64 *)&cmdbuf[2];
+
+  return cmdbuf[1];
+}
+
+Result FSREG_GetProgramInfo(exheader_header *exheader, u32 entry_count, u64 prog_handle)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x403,3,0); // 0x40300C0
+  cmdbuf[1] = entry_count;
+  *(u64 *)&cmdbuf[2] = prog_handle;
+  cmdbuf[64] = ((entry_count << 10) << 14) | 2;
+  cmdbuf[65] = (u32) exheader;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSREG_UnloadProgram(u64 prog_handle)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x405,2,0); // 0x4050080
+  cmdbuf[1] = (u32) (prog_handle);
+  cmdbuf[2] = (u32) (prog_handle >> 32);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSREG_Unregister(u32 pid)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x402,1,0); // 0x4020040
+  cmdbuf[1] = pid;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo *info, void *storageinfo)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x401,0xf,0); // 0x40103C0
+  cmdbuf[1] = pid;
+  *(u64 *)&cmdbuf[2] = prog_handle;
+  memcpy(&cmdbuf[4], &info->programId, sizeof(u64));
+  *(u8 *)&cmdbuf[6] = info->mediaType;
+  memcpy(((u8 *)&cmdbuf[6])+1, &info->padding, 7);
+  memcpy((u8 *)&cmdbuf[8], storageinfo, 32);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(fsregHandle))) return ret;
+
+  return cmdbuf[1];
+}

sysmodules/loader/source/fsreg.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <3ds/types.h>
+#include "exheader.h"
+
+Result fsregInit(void);
+void fsregExit(void);
+Result FSREG_CheckHostLoadId(u64 prog_handle);
+Result FSREG_LoadProgram(u64 *prog_handle, FS_ProgramInfo *title);
+Result FSREG_GetProgramInfo(exheader_header *exheader, u32 entry_count, u64 prog_handle);
+Result FSREG_UnloadProgram(u64 prog_handle);
+Result FSREG_Unregister(u32 pid);
+Result FSREG_Register(u32 pid, u64 prog_handle, FS_ProgramInfo *info, void *storageinfo);

sysmodules/loader/source/ifile.c

@@ -0,0 +1,66 @@
+#include <3ds.h>
+#include "ifile.h"
+#include "fsldr.h"
+
+Result IFile_Open(IFile *file, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 flags)
+{
+  Result res;
+
+  res = FSLDR_OpenFileDirectly(&file->handle, archiveId, archivePath, filePath, flags, 0);
+  file->pos = 0;
+  file->size = 0;
+  return res;
+}
+
+Result IFile_Close(IFile *file)
+{
+  return FSFILE_Close(file->handle);
+}
+
+Result IFile_GetSize(IFile *file, u64 *size)
+{
+  Result res;
+
+  res = FSFILE_GetSize(file->handle, size);
+  file->size = *size;
+  return res;
+}
+
+Result IFile_Read(IFile *file, u64 *total, void *buffer, u32 len)
+{
+  u32 read;
+  u32 left;
+  char *buf;
+  u64 cur;
+  Result res;
+
+  if (len == 0)
+  {
+    *total = 0;
+    return 0;
+  }
+
+  buf = (char *)buffer;
+  cur = 0;
+  left = len;
+  while (1)
+  {
+    res = FSFILE_Read(file->handle, &read, file->pos, buf, left);
+    if (R_FAILED(res))
+    {
+      break;
+    }
+
+    cur += read;
+    file->pos += read;
+    if (read == left)
+    {
+      break;
+    }
+    buf += read;
+    left -= read;
+  }
+
+  *total = cur;
+  return res;
+}

sysmodules/loader/source/ifile.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <3ds/types.h>
+
+typedef struct
+{
+  Handle handle;
+  u64 pos;
+  u64 size;
+} IFile;
+
+Result IFile_Open(IFile *file, FS_ArchiveID archiveId, FS_Path archivePath, FS_Path filePath, u32 flags);
+Result IFile_Close(IFile *file);
+Result IFile_GetSize(IFile *file, u64 *size);
+Result IFile_Read(IFile *file, u64 *total, void *buffer, u32 len);

sysmodules/loader/source/loader.c

@@ -0,0 +1,593 @@
+#include <3ds.h>
+#include "memory.h"
+#include "patcher.h"
+#include "exheader.h"
+#include "ifile.h"
+#include "fsldr.h"
+#include "fsreg.h"
+#include "pxipm.h"
+#include "srvsys.h"
+
+#define MAX_SESSIONS 1
+
+const char CODE_PATH[] = {0x01, 0x00, 0x00, 0x00, 0x2E, 0x63, 0x6F, 0x64, 0x65, 0x00, 0x00, 0x00};
+
+typedef struct
+{
+  u32 text_addr;
+  u32 text_size;
+  u32 ro_addr;
+  u32 ro_size;
+  u32 data_addr;
+  u32 data_size;
+  u32 total_size;
+} prog_addrs_t;
+
+static Handle g_handles[MAX_SESSIONS+2];
+static int g_active_handles;
+static u64 g_cached_prog_handle;
+static exheader_header g_exheader;
+static char g_ret_buf[1024];
+
+static int lzss_decompress(u8 *end)
+{
+  unsigned int v1; // r1@2
+  u8 *v2; // r2@2
+  u8 *v3; // r3@2
+  u8 *v4; // r1@2
+  char v5; // r5@4
+  char v6; // t1@4
+  signed int v7; // r6@4
+  int v9; // t1@7
+  u8 *v11; // r3@8
+  int v12; // r12@8
+  int v13; // t1@8
+  int v14; // t1@8
+  unsigned int v15; // r7@8
+  int v16; // r12@8
+  int ret;
+
+  ret = 0;
+  if ( end )
+  {
+    v1 = *((u32 *)end - 2);
+    v2 = &end[*((u32 *)end - 1)];
+    v3 = &end[-(v1 >> 24)];
+    v4 = &end[-(v1 & 0xFFFFFF)];
+    while ( v3 > v4 )
+    {
+      v6 = *(v3-- - 1);
+      v5 = v6;
+      v7 = 8;
+      while ( 1 )
+      {
+        if ( (v7-- < 1) )
+          break;
+        if ( v5 & 0x80 )
+        {
+          v13 = *(v3 - 1);
+          v11 = v3 - 1;
+          v12 = v13;
+          v14 = *(v11 - 1);
+          v3 = v11 - 1;
+          v15 = ((v14 | (v12 << 8)) & 0xFFFF0FFF) + 2;
+          v16 = v12 + 32;
+          do
+          {
+            ret = v2[v15];
+            *(v2-- - 1) = ret;
+            v16 -= 16;
+          }
+          while ( !(v16 < 0) );
+        }
+        else
+        {
+          v9 = *(v3-- - 1);
+          ret = v9;
+          *(v2-- - 1) = v9;
+        }
+        v5 *= 2;
+        if ( v3 <= v4 )
+          return ret;
+      }
+    }
+  }
+  return ret;
+}
+
+static Result allocate_shared_mem(prog_addrs_t *shared, prog_addrs_t *vaddr, int flags)
+{
+  u32 dummy;
+
+  memcpy(shared, vaddr, sizeof(prog_addrs_t));
+  shared->text_addr = 0x10000000;
+  shared->ro_addr = shared->text_addr + (shared->text_size << 12);
+  shared->data_addr = shared->ro_addr + (shared->ro_size << 12);
+  return svcControlMemory(&dummy, shared->text_addr, 0, shared->total_size << 12, (flags & 0xF00) | MEMOP_ALLOC, MEMPERM_READ | MEMPERM_WRITE);
+}
+
+static Result load_code(u64 progid, prog_addrs_t *shared, u64 prog_handle, int is_compressed)
+{
+  IFile file;
+  FS_Path archivePath;
+  FS_Path filePath;
+  Result res;
+  u64 size;
+  u64 total;
+
+  archivePath.type = PATH_BINARY;
+  archivePath.data = &prog_handle;
+  archivePath.size = 8;
+
+  filePath.type = PATH_BINARY;
+  filePath.data = CODE_PATH;
+  filePath.size = sizeof(CODE_PATH);
+  if (R_FAILED(IFile_Open(&file, ARCHIVE_SAVEDATA_AND_CONTENT2, archivePath, filePath, FS_OPEN_READ)))
+  {
+    svcBreak(USERBREAK_ASSERT);
+  }
+
+  // get file size
+  if (R_FAILED(IFile_GetSize(&file, &size)))
+  {
+    IFile_Close(&file);
+    svcBreak(USERBREAK_ASSERT);
+  }
+
+  // check size
+  if (size > (u64)shared->total_size << 12)
+  {
+    IFile_Close(&file);
+    return 0xC900464F;
+  }
+
+  // read code
+  res = IFile_Read(&file, &total, (void *)shared->text_addr, size);
+  IFile_Close(&file); // done reading
+  if (R_FAILED(res))
+  {
+    svcBreak(USERBREAK_ASSERT);
+  }
+
+  // decompress
+  if (is_compressed)
+  {
+    lzss_decompress((u8 *)shared->text_addr + size);
+  }
+
+  u16 progver = g_exheader.codesetinfo.flags.remasterversion[0] | (g_exheader.codesetinfo.flags.remasterversion[1] << 8);
+
+  // patch
+  patchCode(progid, progver, (u8 *)shared->text_addr, shared->total_size << 12, g_exheader.codesetinfo.text.codesize, g_exheader.codesetinfo.ro.codesize, g_exheader.codesetinfo.data.codesize, g_exheader.codesetinfo.ro.address, g_exheader.codesetinfo.data.address);
+
+  return 0;
+}
+
+static Result loader_GetProgramInfo(exheader_header *exheader, u64 prog_handle)
+{
+  Result res;
+
+  if (prog_handle >> 32 == 0xFFFF0000)
+  {
+    return FSREG_GetProgramInfo(exheader, 1, prog_handle);
+  }
+  else
+  {
+    res = FSREG_CheckHostLoadId(prog_handle);
+    //if ((res >= 0 && (unsigned)res >> 27) || (res < 0 && ((unsigned)res >> 27)-32))
+    //so use PXIPM if FSREG fails OR returns "info", is the second condition a bug?
+    if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS))
+    {
+      return PXIPM_GetProgramInfo(exheader, prog_handle);
+    }
+    else
+    {
+      return FSREG_GetProgramInfo(exheader, 1, prog_handle);
+    }
+  }
+}
+
+static Result loader_LoadProcess(Handle *process, u64 prog_handle)
+{
+  Result res;
+  int count;
+  u32 flags;
+  u32 desc;
+  u32 dummy;
+  prog_addrs_t shared_addr;
+  prog_addrs_t vaddr;
+  Handle codeset;
+  CodeSetInfo codesetinfo;
+  u32 data_mem_size;
+  u64 progid;
+
+  // make sure the cached info corrosponds to the current prog_handle
+  if (g_cached_prog_handle != prog_handle)
+  {
+    res = loader_GetProgramInfo(&g_exheader, prog_handle);
+    g_cached_prog_handle = prog_handle;
+    if (res < 0)
+    {
+      g_cached_prog_handle = 0;
+      return res;
+    }
+  }
+
+  // get kernel flags
+  flags = 0;
+  for (count = 0; count < 28; count++)
+  {
+    desc = g_exheader.arm11kernelcaps.descriptors[count];
+    if (0x1FE == desc >> 23)
+    {
+      flags = desc & 0xF00;
+    }
+  }
+  if (flags == 0)
+  {
+    return MAKERESULT(RL_PERMANENT, RS_INVALIDARG, 1, 2);
+  }
+
+  // allocate process memory
+  vaddr.text_addr = g_exheader.codesetinfo.text.address;
+  vaddr.text_size = (g_exheader.codesetinfo.text.codesize + 4095) >> 12;
+  vaddr.ro_addr = g_exheader.codesetinfo.ro.address;
+  vaddr.ro_size = (g_exheader.codesetinfo.ro.codesize + 4095) >> 12;
+  vaddr.data_addr = g_exheader.codesetinfo.data.address;
+  vaddr.data_size = (g_exheader.codesetinfo.data.codesize + 4095) >> 12;
+  data_mem_size = (g_exheader.codesetinfo.data.codesize + g_exheader.codesetinfo.bsssize + 4095) >> 12;
+  vaddr.total_size = vaddr.text_size + vaddr.ro_size + vaddr.data_size;
+  if ((res = allocate_shared_mem(&shared_addr, &vaddr, flags)) < 0)
+  {
+    return res;
+  }
+
+  // load code
+  progid = g_exheader.arm11systemlocalcaps.programid;
+  if ((res = load_code(progid, &shared_addr, prog_handle, g_exheader.codesetinfo.flags.flag & 1)) >= 0)
+  {
+    memcpy(&codesetinfo.name, g_exheader.codesetinfo.name, 8);
+    codesetinfo.program_id = progid;
+    codesetinfo.text_addr = vaddr.text_addr;
+    codesetinfo.text_size = vaddr.text_size;
+    codesetinfo.text_size_total = vaddr.text_size;
+    codesetinfo.ro_addr = vaddr.ro_addr;
+    codesetinfo.ro_size = vaddr.ro_size;
+    codesetinfo.ro_size_total = vaddr.ro_size;
+    codesetinfo.rw_addr = vaddr.data_addr;
+    codesetinfo.rw_size = vaddr.data_size;
+    codesetinfo.rw_size_total = data_mem_size;
+    res = svcCreateCodeSet(&codeset, &codesetinfo, (void *)shared_addr.text_addr, (void *)shared_addr.ro_addr, (void *)shared_addr.data_addr);
+    if (res >= 0)
+    {
+      res = svcCreateProcess(process, codeset, g_exheader.arm11kernelcaps.descriptors, count);
+      svcCloseHandle(codeset);
+      if (res >= 0)
+      {
+        return 0;
+      }
+    }
+  }
+
+  svcControlMemory(&dummy, shared_addr.text_addr, 0, shared_addr.total_size << 12, MEMOP_FREE, 0);
+  return res;
+}
+
+static Result loader_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update)
+{
+  Result res;
+  u64 prog_id;
+
+  prog_id = title->programId;
+  if (prog_id >> 32 != 0xFFFF0000)
+  {
+    res = FSREG_CheckHostLoadId(prog_id);
+    //if ((res >= 0 && (unsigned)res >> 27) || (res < 0 && ((unsigned)res >> 27)-32))
+    if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS))
+    {
+      res = PXIPM_RegisterProgram(prog_handle, title, update);
+      if (res < 0)
+      {
+        return res;
+      }
+      if (*prog_handle >> 32 != 0xFFFF0000)
+      {
+        res = FSREG_CheckHostLoadId(*prog_handle);
+        //if ((res >= 0 && (unsigned)res >> 27) || (res < 0 && ((unsigned)res >> 27)-32))
+        if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS))
+        {
+          return 0;
+        }
+      }
+      svcBreak(USERBREAK_ASSERT);
+    }
+  }
+
+  if ((title->mediaType != update->mediaType) || (prog_id != update->programId))
+  {
+    svcBreak(USERBREAK_ASSERT);
+  }
+  res = FSREG_LoadProgram(prog_handle, title);
+  if (R_SUCCEEDED(res))
+  {
+    if (*prog_handle >> 32 == 0xFFFF0000)
+    {
+      return 0;
+    }
+    res = FSREG_CheckHostLoadId(*prog_handle);
+    //if ((res >= 0 && (unsigned)res >> 27) || (res < 0 && ((unsigned)res >> 27)-32))
+    if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS))
+    {
+      svcBreak(USERBREAK_ASSERT);
+    }
+  }
+  return res;
+}
+
+static Result loader_UnregisterProgram(u64 prog_handle)
+{
+  Result res;
+
+  if (prog_handle >> 32 == 0xFFFF0000)
+  {
+    return FSREG_UnloadProgram(prog_handle);
+  }
+  else
+  {
+    res = FSREG_CheckHostLoadId(prog_handle);
+    //if ((res >= 0 && (unsigned)res >> 27) || (res < 0 && ((unsigned)res >> 27)-32))
+    if (R_FAILED(res) || (R_SUCCEEDED(res) && R_LEVEL(res) != RL_SUCCESS))
+    {
+      return PXIPM_UnregisterProgram(prog_handle);
+    }
+    else
+    {
+      return FSREG_UnloadProgram(prog_handle);
+    }
+  }
+}
+
+static void handle_commands(void)
+{
+  FS_ProgramInfo title;
+  FS_ProgramInfo update;
+  u32* cmdbuf;
+  u16 cmdid;
+  int res;
+  Handle handle;
+  u64 prog_handle;
+
+  cmdbuf = getThreadCommandBuffer();
+  cmdid = cmdbuf[0] >> 16;
+  res = 0;
+  switch (cmdid)
+  {
+    case 1: // LoadProcess
+    {
+      res = loader_LoadProcess(&handle, *(u64 *)&cmdbuf[1]);
+      cmdbuf[0] = 0x10042;
+      cmdbuf[1] = res;
+      cmdbuf[2] = 16;
+      cmdbuf[3] = handle;
+      break;
+    }
+    case 2: // RegisterProgram
+    {
+      memcpy(&title, &cmdbuf[1], sizeof(FS_ProgramInfo));
+      memcpy(&update, &cmdbuf[5], sizeof(FS_ProgramInfo));
+      res = loader_RegisterProgram(&prog_handle, &title, &update);
+      cmdbuf[0] = 0x200C0;
+      cmdbuf[1] = res;
+      *(u64 *)&cmdbuf[2] = prog_handle;
+      break;
+    }
+    case 3: // UnregisterProgram
+    {
+      if (g_cached_prog_handle == prog_handle)
+      {
+        g_cached_prog_handle = 0;
+      }
+      cmdbuf[0] = 0x30040;
+      cmdbuf[1] = loader_UnregisterProgram(*(u64 *)&cmdbuf[1]);
+      break;
+    }
+    case 4: // GetProgramInfo
+    {
+      prog_handle = *(u64 *)&cmdbuf[1];
+      if (prog_handle != g_cached_prog_handle)
+      {
+        res = loader_GetProgramInfo(&g_exheader, prog_handle);
+        if (res >= 0)
+        {
+          g_cached_prog_handle = prog_handle;
+        }
+        else
+        {
+          g_cached_prog_handle = 0;
+        }
+      }
+      memcpy(&g_ret_buf, &g_exheader, 1024);
+      cmdbuf[0] = 0x40042;
+      cmdbuf[1] = res;
+      cmdbuf[2] = 0x1000002;
+      cmdbuf[3] = (u32) &g_ret_buf;
+      break;
+    }
+    default: // error
+    {
+      cmdbuf[0] = 0x40;
+      cmdbuf[1] = 0xD900182F;
+      break;
+    }
+  }
+}
+
+static Result should_terminate(int *term_request)
+{
+  u32 notid;
+  Result ret;
+
+  ret = srvSysReceiveNotification(&notid);
+  if (R_FAILED(ret))
+  {
+    return ret;
+  }
+  if (notid == 0x100) // term request
+  {
+    *term_request = 1;
+  }
+  return 0;
+}
+
+// this is called before main
+void __appInit()
+{
+  srvSysInit();
+  fsregInit();
+  fsldrInit();
+  pxipmInit();
+}
+
+// this is called after main exits
+void __appExit()
+{
+  pxipmExit();
+  fsldrExit();
+  fsregExit();
+  srvSysExit();
+}
+
+// stubs for non-needed pre-main functions
+void __sync_init();
+void __sync_fini();
+void __system_initSyscalls();
+ 
+void __ctru_exit()
+{
+  __appExit();
+  __sync_fini();
+  svcExitProcess();
+}
+ 
+void initSystem()
+{
+  __sync_init();
+  __system_initSyscalls();
+  __appInit();
+}
+
+int main()
+{
+  Result ret;
+  Handle handle;
+  Handle reply_target;
+  Handle *srv_handle;
+  Handle *notification_handle;
+  s32 index;
+  int i;
+  int term_request;
+  u32* cmdbuf;
+
+  ret = 0;
+
+  srv_handle = &g_handles[1];
+  notification_handle = &g_handles[0];
+
+  if (R_FAILED(srvSysRegisterService(srv_handle, "Loader", MAX_SESSIONS)))
+  {
+    svcBreak(USERBREAK_ASSERT);
+  }
+
+  if (R_FAILED(srvSysEnableNotification(notification_handle)))
+  {
+    svcBreak(USERBREAK_ASSERT);
+  }
+
+  g_active_handles = 2;
+  g_cached_prog_handle = 0;
+  index = 1;
+
+  reply_target = 0;
+  term_request = 0;
+  do
+  {
+    if (reply_target == 0)
+    {
+      cmdbuf = getThreadCommandBuffer();
+      cmdbuf[0] = 0xFFFF0000;
+    }
+    ret = svcReplyAndReceive(&index, g_handles, g_active_handles, reply_target);
+
+    if (R_FAILED(ret))
+    {
+      // check if any handle has been closed
+      if (ret == (int)0xC920181A)
+      {
+        if (index == -1)
+        {
+          for (i = 2; i < MAX_SESSIONS+2; i++)
+          {
+            if (g_handles[i] == reply_target)
+            {
+              index = i;
+              break;
+            }
+          }
+        }
+        svcCloseHandle(g_handles[index]);
+        g_handles[index] = g_handles[g_active_handles-1];
+        g_active_handles--;
+        reply_target = 0;
+      }
+      else 
+      {
+        svcBreak(USERBREAK_ASSERT);
+      }
+    }
+    else
+    {
+      // process responses
+      reply_target = 0;
+      switch (index)
+      {
+        case 0: // notification
+        {
+          if (R_FAILED(should_terminate(&term_request)))
+          {
+            svcBreak(USERBREAK_ASSERT);
+          }
+          break;
+        }
+        case 1: // new session
+        {
+          if (R_FAILED(svcAcceptSession(&handle, *srv_handle)))
+          {
+            svcBreak(USERBREAK_ASSERT);
+          }
+          if (g_active_handles < MAX_SESSIONS+2)
+          {
+            g_handles[g_active_handles] = handle;
+            g_active_handles++;
+          }
+          else
+          {
+            svcCloseHandle(handle);
+          }
+          break;
+        }
+        default: // session
+        {
+          handle_commands();
+          reply_target = g_handles[index];
+          break;
+        }
+      }
+    }
+  } while (!term_request || g_active_handles != 2);
+
+  srvSysUnregisterService("Loader");
+  svcCloseHandle(*srv_handle);
+  svcCloseHandle(*notification_handle);
+
+  return 0;
+}

sysmodules/loader/source/memory.c

@@ -0,0 +1,49 @@
+#include "memory.h"
+
+void memcpy(void *dest, const void *src, u32 size)
+{
+    u8 *destc = (u8 *)dest;
+    const u8 *srcc = (const u8 *)src;
+
+    for(u32 i = 0; i < size; i++)
+        destc[i] = srcc[i];
+}
+
+int memcmp(const void *buf1, const void *buf2, u32 size)
+{
+    const u8 *buf1c = (const u8 *)buf1,
+             *buf2c = (const u8 *)buf2;
+
+    for(u32 i = 0; i < size; i++)
+    {
+        int cmp = buf1c[i] - buf2c[i];
+        if(cmp != 0) return cmp;
+    }
+
+    return 0;
+}
+
+//Boyer-Moore Horspool algorithm, adapted from http://www-igm.univ-mlv.fr/~lecroq/string/node18.html#SECTION00180
+u8 *memsearch(u8 *startPos, const void *pattern, u32 size, u32 patternSize)
+{
+    const u8 *patternc = (const u8 *)pattern;
+    u32 table[256];
+
+    //Preprocessing
+    for(u32 i = 0; i < 256; i++)
+        table[i] = patternSize;
+    for(u32 i = 0; i < patternSize - 1; i++)
+        table[patternc[i]] = patternSize - i - 1;
+
+    //Searching
+    u32 j = 0;
+    while(j <= size - patternSize)
+    {
+        u8 c = startPos[j + patternSize - 1];
+        if(patternc[patternSize - 1] == c && memcmp(pattern, startPos + j, patternSize - 1) == 0)
+            return startPos + j;
+        j += table[c];
+    }
+
+    return NULL;
+}

sysmodules/loader/source/memory.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <3ds/types.h>
+
+void memcpy(void *dest, const void *src, u32 size);
+int memcmp(const void *buf1, const void *buf2, u32 size);
+u8 *memsearch(u8 *startPos, const void *pattern, u32 size, u32 patternSize);

sysmodules/loader/source/patcher.c

@@ -0,0 +1,913 @@
+#include <3ds.h>
+#include "patcher.h"
+#include "memory.h"
+#include "strings.h"
+#include "fsldr.h"
+#include "ifile.h"
+#include "CFWInfo.h"
+#include "../build/bundled.h"
+
+static CFWInfo info;
+
+static u32 patchMemory(u8 *start, u32 size, const void *pattern, u32 patSize, s32 offset, const void *replace, u32 repSize, u32 count)
+{
+    u32 i;
+
+    for(i = 0; i < count; i++)
+    {
+        u8 *found = memsearch(start, pattern, size, patSize);
+
+        if(found == NULL) break;
+
+        memcpy(found + offset, replace, repSize);
+
+        u32 at = (u32)(found - start);
+
+        if(at + patSize > size) break;
+
+        size -= at + patSize;
+        start = found + patSize;
+    }
+
+    return i;
+}
+
+static Result fileOpen(IFile *file, FS_ArchiveID archiveId, const char *path, int flags)
+{
+    FS_Path filePath = {PATH_ASCII, strnlen(path, 255) + 1, path},
+            archivePath = {PATH_EMPTY, 1, (u8 *)""};
+
+    return IFile_Open(file, archiveId, archivePath, filePath, flags);
+}
+
+static bool dirCheck(FS_ArchiveID archiveId, const char *path)
+{
+    bool ret;
+    Handle handle;
+    FS_Archive archive;
+    FS_Path dirPath = {PATH_ASCII, strnlen(path, 255) + 1, path},
+            archivePath = {PATH_EMPTY, 1, (u8 *)""};
+
+    if(R_FAILED(FSLDR_OpenArchive(&archive, archiveId, archivePath))) ret = false;
+    else
+    {
+        ret = R_SUCCEEDED(FSLDR_OpenDirectory(&handle, archive, dirPath));
+        if(ret) FSDIR_Close(handle);
+        FSLDR_CloseArchive(archive);
+    }
+
+    return ret;
+}
+
+static bool openLumaFile(IFile *file, const char *path)
+{
+    FS_ArchiveID archiveId = ISSDMODE ? ARCHIVE_SDMC : ARCHIVE_NAND_RW;
+
+    return R_SUCCEEDED(fileOpen(file, archiveId, path, FS_OPEN_READ));
+}
+
+static u32 checkLumaDir(const char *path)
+{
+    FS_ArchiveID archiveId = ISSDMODE ? ARCHIVE_SDMC : ARCHIVE_NAND_RW;
+
+    return dirCheck(archiveId, path) ? archiveId : 0;
+}
+
+static inline void loadCFWInfo(void)
+{
+    static bool infoLoaded = false;
+
+    if(infoLoaded) return;
+
+    svcGetCFWInfo(&info);
+
+    IFile file;
+    if(LOADERFLAG(ISSAFEMODE)) fileOpen(&file, ARCHIVE_SDMC, "/", FS_OPEN_READ); //Init SD card if SAFE_MODE is being booted
+
+    infoLoaded = true;
+}
+
+static inline bool secureInfoExists(void)
+{
+    static bool exists = false;
+
+    if(exists) return true;
+
+    IFile file;
+    if(R_SUCCEEDED(fileOpen(&file, ARCHIVE_NAND_RW, "/sys/SecureInfo_C", FS_OPEN_READ)))
+    {
+        exists = true;
+        IFile_Close(&file);
+    }
+
+    return exists;
+}
+
+static inline void loadCustomVerString(u16 *out, u32 *verStringSize, u32 currentNand)
+{
+    static const char *paths[] = { "/luma/customversion_sys.txt",
+                                   "/luma/customversion_emu.txt",
+                                   "/luma/customversion_emu2.txt",
+                                   "/luma/customversion_emu3.txt",
+                                   "/luma/customversion_emu4.txt" };
+
+    IFile file;
+
+    if(!openLumaFile(&file, paths[currentNand])) return;
+
+    u64 fileSize;
+
+    if(R_FAILED(IFile_GetSize(&file, &fileSize)) || fileSize > 62) goto exit;
+
+    u8 buf[62];
+    u64 total;
+
+    if(R_FAILED(IFile_Read(&file, &total, buf, fileSize))) goto exit;
+
+    static const u8 bom[] = {0xEF, 0xBB, 0xBF};
+    u32 finalSize = 0;
+
+    //Convert from UTF-8 to UTF-16 (Nintendo doesn't support 4-byte UTF-16, so 4-byte UTF-8 is unsupported)
+    for(u32 increase, fileSizeTmp = (u32)fileSize, i = (fileSizeTmp > 2 && memcmp(buf, bom, 3) == 0) ? 3 : 0;
+        i < fileSizeTmp && finalSize < 19; i += increase, finalSize++)
+    {
+        if((buf[i] & 0x80) == 0 && !(buf[i] == 0xA || buf[i] == 0xD))
+        {
+            increase = 1;
+            out[finalSize] = (u16)buf[i];
+        }
+        else if((buf[i] & 0xE0) == 0xC0 && i + 1 < fileSizeTmp && (buf[i + 1] & 0xC0) == 0x80)
+        {
+            increase = 2;
+            out[finalSize] = (u16)(((buf[i] & 0x1F) << 6) | (buf[i + 1] & 0x3F));
+        }
+        else if((buf[i] & 0xF0) == 0xE0 && i + 2 < fileSizeTmp && (buf[i + 1] & 0xC0) == 0x80 && (buf[i + 2] & 0xC0) == 0x80)
+        {
+            increase = 3;
+            out[finalSize] = (u16)(((buf[i] & 0xF) << 12) | ((buf[i + 1] & 0x3F) << 6) | (buf[i + 2] & 0x3F));
+        }
+        else break;
+    }
+
+    if(finalSize > 0)
+    {
+        if(finalSize > 5 && finalSize < 19) out[finalSize++] = 0;
+        *verStringSize = finalSize * 2;
+    }
+
+exit:
+    IFile_Close(&file);
+}
+
+static inline u8 *getCfgOffsets(u8 *code, u32 size, u32 *CFGUHandleOffset)
+{
+    /* HANS:
+       Look for error code which is known to be stored near cfg:u handle
+       this way we can find the right candidate
+       (handle should also be stored right after end of candidate function) */
+
+    u32 n = 0,
+        possible[24];
+
+    for(u8 *pos = code + 16; n < 24 && pos <= code + size - 16; pos += 4)
+    {
+        if(*(u32 *)pos != 0xD8A103F9) continue;
+
+        for(u32 *l = (u32 *)pos - 4; n < 24 && l < (u32 *)pos + 4; l++)
+            if(*l <= 0x10000000) possible[n++] = *l;
+    }
+
+    if(!n) return NULL;
+
+    for(u8 *CFGU_GetConfigInfoBlk2_endPos = code; CFGU_GetConfigInfoBlk2_endPos <= code + size - 12; CFGU_GetConfigInfoBlk2_endPos += 4)
+    {
+        //There might be multiple implementations of GetConfigInfoBlk2 but let's search for the one we want
+        u32 *cmp = (u32 *)CFGU_GetConfigInfoBlk2_endPos;
+
+        if(cmp[0] != 0xE8BD8010 || cmp[1] != 0x00010082) continue;
+
+        for(u32 i = 0; i < n; i++)
+            if(possible[i] == cmp[2])
+        {
+            *CFGUHandleOffset = cmp[2];
+
+            return CFGU_GetConfigInfoBlk2_endPos;
+        }
+
+        CFGU_GetConfigInfoBlk2_endPos += 4;
+    }
+
+    return NULL;
+}
+
+static inline bool patchCfgGetLanguage(u8 *code, u32 size, u8 languageId, u8 *CFGU_GetConfigInfoBlk2_endPos)
+{
+    u8 *CFGU_GetConfigInfoBlk2_startPos; //Let's find STMFD SP (there might be a NOP before, but nevermind)
+
+    for(CFGU_GetConfigInfoBlk2_startPos = CFGU_GetConfigInfoBlk2_endPos - 4;
+        *((u16 *)CFGU_GetConfigInfoBlk2_startPos + 1) != 0xE92D; CFGU_GetConfigInfoBlk2_startPos -= 4)
+        if(CFGU_GetConfigInfoBlk2_startPos < code + 4) return false;
+
+    for(u8 *languageBlkIdPos = code; languageBlkIdPos <= code + size - 4; languageBlkIdPos += 4)
+    {
+        if(*(u32 *)languageBlkIdPos != 0xA0002) continue;
+
+        for(u8 *instr = languageBlkIdPos - 8; instr >= languageBlkIdPos - 0x1008 && instr >= code + 4; instr -= 4) //Should be enough
+        {
+            if(instr[3] != 0xEB) continue; //We're looking for BL
+
+            u8 *calledFunction = instr;
+            u32 i = 0;
+
+            do
+            {
+                u32 low24 = (*(u32 *)calledFunction & 0x00FFFFFF) << 2;
+                u32 signMask = (u32)(-(low24 >> 25)) & 0xFC000000; //Sign extension
+                s32 offset = (s32)(low24 | signMask) + 8;          //Branch offset + 8 for prefetch
+
+                calledFunction += offset;
+
+                if(calledFunction >= CFGU_GetConfigInfoBlk2_startPos - 4 && calledFunction <= CFGU_GetConfigInfoBlk2_endPos)
+                {
+                    *((u32 *)instr - 1)  = 0xE3A00000 | languageId; //mov    r0, sp                 => mov r0, =languageId
+                    *(u32 *)instr        = 0xE5CD0000;              //bl     CFGU_GetConfigInfoBlk2 => strb r0, [sp]
+                    *((u32 *)instr + 1)  = 0xE3B00000;              //(1 or 2 instructions)         => movs r0, 0             (result code)
+
+                    //We're done
+                    return true;
+                }
+
+                i++;
+            }
+            while(i < 2 && calledFunction[3] == 0xEA);
+        }
+    }
+
+    return false;
+}
+
+static inline void patchCfgGetRegion(u8 *code, u32 size, u8 regionId, u32 CFGUHandleOffset)
+{
+    for(u8 *cmdPos = code; cmdPos <= code + size - 28; cmdPos += 4)
+    {
+        u32 *cmp = (u32 *)cmdPos;
+
+        if(*cmp != 0xE3A00802) continue;
+
+        for(u32 i = 1; i < 3; i++)
+            if((*(cmp - i) & 0xFFFF0FFF) == 0xEE1D0F70 && *((u16 *)cmdPos + 5) == 0xE59F &&
+               *(u32 *)(cmdPos + 16 + *((u16 *)cmdPos + 4)) == CFGUHandleOffset)
+        {
+            cmp[3] = 0xE3A00000 | regionId; //mov    r0, =regionId
+            cmp[4] = 0xE5C40008;            //strb   r0, [r4, #8]
+            cmp[5] = 0xE3A00000;            //mov    r0, #0 (result code)
+            cmp[6] = 0xE5840004;            //str    r0, [r4, #4]
+
+            //The remaining, not patched, function code will do the rest for us
+            return;
+        }
+    }
+}
+
+static u32 findFunctionStart(u8 *code, u32 pos)
+{
+    while(pos >= 4)
+    {
+        pos -= 4;
+        if(*(u16 *)(code + pos + 2) == 0xE92D) return pos;
+    }
+
+    return 0xFFFFFFFF;
+}
+
+static inline bool findLayeredFsSymbols(u8 *code, u32 size, u32 *fsMountArchive, u32 *fsRegisterArchive, u32 *fsTryOpenFile, u32 *fsOpenFileDirectly)
+{
+    u32 found = 0,
+        *temp = NULL;
+
+    for(u32 addr = 0; addr <= size - 4; addr += 4)
+    {
+        u32 *addr32 = (u32 *)(code + addr);
+
+        switch(*addr32)
+        {
+            case 0xE5970010:
+                if(addr <= size - 12 && *fsMountArchive == 0xFFFFFFFF && addr32[1] == 0xE1CD20D8 && (addr32[2] & 0xFFFFFF) == 0x008D0000) temp = fsMountArchive;
+                break;
+            case 0xE24DD028:
+                if(addr <= size - 16 && *fsMountArchive == 0xFFFFFFFF && addr32[1] == 0xE1A04000 && addr32[2] == 0xE59F60A8 && addr32[3] == 0xE3A0C001) temp = fsMountArchive;
+                break;
+            case 0xE3500008:
+                if(addr <= size - 12 && *fsRegisterArchive == 0xFFFFFFFF && (addr32[1] & 0xFFF00FF0) == 0xE1800400 && (addr32[2] & 0xFFF00FF0) == 0xE1800FC0) temp = fsRegisterArchive;
+                break;
+            case 0xE351003A:
+                if(addr <= size - 0x40 && *fsTryOpenFile == 0xFFFFFFFF && addr32[1] == 0x1AFFFFFC && addr32[0xD] == 0xE590C000 && addr32[0xF] == 0xE12FFF3C) temp = fsTryOpenFile;
+                break;
+            case 0x08030204:
+                if(*fsOpenFileDirectly == 0xFFFFFFFF) temp = fsOpenFileDirectly;
+                break;
+        }
+
+        if(temp != NULL)
+        {
+            *temp = findFunctionStart(code, addr);
+
+            if(*temp != 0xFFFFFFFF)
+            {
+                found++;
+                if(found == 4) break;
+            }
+
+            temp = NULL;
+        }
+    }
+
+    return found == 4;
+}
+
+static inline bool findLayeredFsPayloadOffset(u8 *code, u32 size, u32 roSize, u32 dataSize, u32 roAddress, u32 dataAddress, u32 *payloadOffset, u32 *pathOffset, u32 *pathAddress)
+{
+    u32 roundedTextSize = ((size + 4095) & 0xFFFFF000),
+        roundedRoSize = ((roSize + 4095) & 0xFFFFF000),
+        roundedDataSize = ((dataSize + 4095) & 0xFFFFF000);
+
+    //First check for sufficient padding at the end of the .text segment
+    if(roundedTextSize - size >= romfsredir_bin_size) *payloadOffset = size;
+    else
+    {
+        //If there isn't enough padding look for the "throwFatalError" function to replace
+        u32 svcConnectToPort = 0xFFFFFFFF;
+
+        for(u32 addr = 4; svcConnectToPort == 0xFFFFFFFF && addr <= size - 4; addr += 4)
+        {
+            if(*(u32 *)(code + addr) == 0xEF00002D)
+                svcConnectToPort = addr - 4;
+        }
+
+        if(svcConnectToPort != 0xFFFFFFFF)
+        {
+            u32 func = 0xFFFFFFFF;
+
+            for(u32 i = 4; func == 0xFFFFFFFF && i <= size - 4; i += 4)
+            {
+                if(*(u32 *)(code + i) != MAKE_BRANCH_LINK(i, svcConnectToPort)) continue;
+
+                func = findFunctionStart(code, i);
+
+                for(u32 pos = func + 4; func != 0xFFFFFFFF && pos <= size - 4 && *(u16 *)(code + pos + 2) != 0xE92D; pos += 4)
+                    if(*(u32 *)(code + pos) == 0xE200167E) func = 0xFFFFFFFF;
+            }
+
+            if(func != 0xFFFFFFFF)
+                *payloadOffset = func;
+        }
+    }
+
+    if(roundedRoSize - roSize >= 39)
+    {
+        *pathOffset = roundedTextSize + roSize;
+        *pathAddress = roAddress + roSize;
+    }
+    else if(roundedDataSize - dataSize >= 39)
+    {
+        *pathOffset = roundedTextSize + roundedRoSize + dataSize;
+        *pathAddress = dataAddress + dataSize;
+    }
+    else
+    {
+        u32 strSpace = 0xFFFFFFFF;
+
+        for(u32 addr = 0; strSpace == 0xFFFFFFFF && addr <= size - 4; addr += 4)
+        {
+            if(*(u32 *)(code + addr) == 0xE3A00B42)
+                strSpace = findFunctionStart(code, addr);
+        }
+
+        if(strSpace != 0xFFFFFFFF)
+        {
+            *pathOffset = strSpace;
+            *pathAddress = 0x100000 + strSpace;
+        }
+    }
+
+    return *payloadOffset != 0 && *pathOffset != 0;
+}
+
+static inline bool applyCodeIpsPatch(u64 progId, u8 *code, u32 size)
+{
+    /* Here we look for "/luma/titles/[u64 titleID in hex, uppercase]/code.ips"
+       If it exists it should be an IPS format patch */
+
+    char path[] = "/luma/titles/0000000000000000/code.ips";
+    progIdToStr(path + 28, progId);
+
+    IFile file;
+
+    if(!openLumaFile(&file, path)) return true;
+
+    bool ret = false;
+    u8 buffer[5];
+    u64 total;
+
+    if(R_FAILED(IFile_Read(&file, &total, buffer, 5)) || total != 5 || memcmp(buffer, "PATCH", 5) != 0) goto exit;
+
+    while(R_SUCCEEDED(IFile_Read(&file, &total, buffer, 3)) && total == 3)
+    {
+        if(memcmp(buffer, "EOF", 3) == 0)
+        {
+            ret = true;
+            break;
+        }
+
+        u32 offset = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
+
+        if(R_FAILED(IFile_Read(&file, &total, buffer, 2)) || total != 2) break;
+
+        u32 patchSize = (buffer[0] << 8) | buffer[1];
+
+        if(!patchSize)
+        {
+            if(R_FAILED(IFile_Read(&file, &total, buffer, 2)) || total != 2) break;
+
+            u32 rleSize = (buffer[0] << 8) | buffer[1];
+
+            if(offset + rleSize > size) break;
+
+            if(R_FAILED(IFile_Read(&file, &total, buffer, 1)) || total != 1) break;
+
+            for(u32 i = 0; i < rleSize; i++)
+                code[offset + i] = buffer[0];
+
+            continue;
+        }
+
+        if(offset + patchSize > size) break;
+
+        if(R_FAILED(IFile_Read(&file, &total, code + offset, patchSize)) || total != patchSize) break;
+    }
+
+exit:
+    IFile_Close(&file);
+
+    return ret;
+}
+
+static inline bool loadTitleCodeSection(u64 progId, u8 *code, u32 size)
+{
+    /* Here we look for "/luma/titles/[u64 titleID in hex, uppercase]/code.bin"
+       If it exists it should be a decrypted and decompressed binary code file */
+
+    char path[] = "/luma/titles/0000000000000000/code.bin";
+    progIdToStr(path + 28, progId);
+
+    IFile file;
+
+    if(!openLumaFile(&file, path)) return true;
+
+    bool ret;
+    u64 fileSize;
+
+    if(R_FAILED(IFile_GetSize(&file, &fileSize)) || fileSize > size) ret = false;
+    else
+    {
+        u64 total;
+
+        ret = R_SUCCEEDED(IFile_Read(&file, &total, code, fileSize)) && total == fileSize;
+    }
+
+    IFile_Close(&file);
+
+    return ret;
+}
+
+static inline bool loadTitleLocaleConfig(u64 progId, u8 *regionId, u8 *languageId)
+{
+    /* Here we look for "/luma/titles/[u64 titleID in hex, uppercase]/locale.txt"
+       If it exists it should contain, for example, "EUR IT" */
+
+    char path[] = "/luma/titles/0000000000000000/locale.txt";
+    progIdToStr(path + 28, progId);
+
+    IFile file;
+
+    if(!openLumaFile(&file, path)) return true;
+
+    bool ret = false;
+    u64 fileSize;
+
+    if(R_FAILED(IFile_GetSize(&file, &fileSize)) || fileSize < 6 || fileSize > 8) goto exit;
+
+    char buf[8];
+    u64 total;
+
+    if(R_FAILED(IFile_Read(&file, &total, buf, fileSize))) goto exit;
+
+    static const char *regions[] = {"JPN", "USA", "EUR", "AUS", "CHN", "KOR", "TWN"},
+                      *languages[] = {"JP", "EN", "FR", "DE", "IT", "ES", "ZH", "KO", "NL", "PT", "RU", "TW"};
+
+    u32 i;
+
+    for(i = 0; i < sizeof(regions) / sizeof(char *); i++)
+    {
+        if(memcmp(buf, regions[i], 3) == 0)
+        {
+            *regionId = (u8)i;
+            break;
+        }
+    }
+
+    if(i != sizeof(regions) / sizeof(char *))
+    {
+        for(i = 0; i < sizeof(languages) / sizeof(char *); i++)
+        {
+            if(memcmp(buf + 4, languages[i], 2) == 0)
+            {
+                *languageId = (u8)i;
+                ret = true;
+                break;
+            }
+        }
+    }
+
+exit:
+    IFile_Close(&file);
+
+    return ret;
+}
+
+static inline bool patchLayeredFs(u64 progId, u8 *code, u32 size, u32 textSize, u32 roSize, u32 dataSize, u32 roAddress, u32 dataAddress)
+{
+    /* Here we look for "/luma/titles/[u64 titleID in hex, uppercase]/romfs"
+       If it exists it should be a folder containing ROMFS files */
+
+    char path[] = "/luma/titles/0000000000000000/romfs";
+    progIdToStr(path + 28, progId);
+
+    u32 archiveId = checkLumaDir(path);
+
+    if(!archiveId) return true;
+
+    u32 fsMountArchive = 0xFFFFFFFF,
+        fsRegisterArchive = 0xFFFFFFFF,
+        fsTryOpenFile = 0xFFFFFFFF,
+        fsOpenFileDirectly = 0xFFFFFFFF,
+        payloadOffset = 0,
+        pathOffset = 0,
+        pathAddress;
+
+    if(!findLayeredFsSymbols(code, textSize, &fsMountArchive, &fsRegisterArchive, &fsTryOpenFile, &fsOpenFileDirectly) ||
+       !findLayeredFsPayloadOffset(code, textSize, roSize, dataSize, roAddress, dataAddress, &payloadOffset, &pathOffset, &pathAddress)) return false;
+
+    static const char *updateRomFsMounts[] = { "rom2:",
+                                               "rex:",
+                                               "patch:",
+                                               "ext:",
+                                               "rom:" };
+    u32 updateRomFsIndex;    
+
+    //Locate update RomFSes
+    for(updateRomFsIndex = 0; updateRomFsIndex < sizeof(updateRomFsMounts) / sizeof(char *) - 1; updateRomFsIndex++)
+    {
+        u32 patternSize = strnlen(updateRomFsMounts[updateRomFsIndex], 255);
+        u8 temp[7];
+        temp[0] = 0;
+        memcpy(temp + 1, updateRomFsMounts[updateRomFsIndex], patternSize);
+        if(memsearch(code, temp, size, patternSize + 1) != NULL) break;
+    }
+
+    //Setup the payload
+    u8 *payload = code + payloadOffset;
+    memcpy(payload, romfsredir_bin, romfsredir_bin_size);
+
+    //Insert symbols in the payload
+    u32 *payload32 = (u32 *)payload;
+    for(u32 i = 0; i < romfsredir_bin_size / 4; i++)
+    {
+        switch(payload32[i])
+        {
+            case 0xdead0000:
+                payload32[i] = *(u32 *)(code + fsOpenFileDirectly);
+                break;
+            case 0xdead0001:
+                payload32[i] = MAKE_BRANCH(payloadOffset + i * 4, fsOpenFileDirectly + 4);
+                break;
+            case 0xdead0002:
+                payload32[i] = *(u32 *)(code + fsTryOpenFile);
+                break;
+            case 0xdead0003:
+                payload32[i] = MAKE_BRANCH(payloadOffset + i * 4, fsTryOpenFile + 4);
+                break;
+            case 0xdead0004:
+                payload32[i] = pathAddress;
+                break;
+            case 0xdead0005:
+                payload32[i] = 0x100000 + fsMountArchive;
+                break;
+            case 0xdead0006:
+                payload32[i] = 0x100000 + fsRegisterArchive;
+                break;
+            case 0xdead0007:
+                payload32[i] = archiveId;
+                break;
+            case 0xdead0008:
+                memcpy(payload32 + i, updateRomFsMounts[updateRomFsIndex], 4);
+                break;
+        }
+    }
+
+    memcpy(code + pathOffset, "lf:", 3);
+    memcpy(code + pathOffset + 3, path, sizeof(path));
+
+    //Place the hooks
+    *(u32 *)(code + fsOpenFileDirectly) = MAKE_BRANCH(fsOpenFileDirectly, payloadOffset);
+    *(u32 *)(code + fsTryOpenFile) = MAKE_BRANCH(fsTryOpenFile, payloadOffset + 12);
+
+    return true;
+}
+
+void patchCode(u64 progId, u16 progVer, u8 *code, u32 size, u32 textSize, u32 roSize, u32 dataSize, u32 roAddress, u32 dataAddress)
+{
+    loadCFWInfo();
+
+    if(((progId == 0x0004003000008F02LL || //USA Home Menu
+         progId == 0x0004003000008202LL || //JPN Home Menu
+         progId == 0x0004003000009802LL) //EUR Home Menu
+        && progVer > 4) ||
+       (progId == 0x000400300000A902LL //KOR Home Menu
+        && progVer > 0) ||
+        progId == 0x000400300000A102LL || //CHN Home Menu
+        progId == 0x000400300000B102LL) //TWN Home Menu
+    {
+        static const u8 pattern[] = {
+            0x0A, 0x0C, 0x00, 0x10
+        },
+                        patch[] = {
+            0x01, 0x00, 0xA0, 0xE3, 0x1E, 0xFF, 0x2F, 0xE1
+        };
+
+        //Patch SMDH region checks
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern), -31,
+                patch,
+                sizeof(patch), 1
+            )) goto error;
+    }
+
+    else if(progId == 0x0004013000003202LL) //FRIENDS
+    {
+        static const u8 pattern[] = {
+            0x42, 0xE0, 0x1E, 0xFF
+        };
+
+        u8 mostRecentFpdVer = 10;
+
+        u8 *off = memsearch(code, pattern, textSize, sizeof(pattern));
+
+        if(off == NULL) goto error;
+
+        //Allow online access to work with old friends modules
+        if(off[0xA] < mostRecentFpdVer) off[0xA] = mostRecentFpdVer;
+    }
+
+    else if((progId == 0x0004001000021000LL || //USA MSET
+             progId == 0x0004001000020000LL || //JPN MSET
+             progId == 0x0004001000022000LL || //EUR MSET
+             progId == 0x0004001000026000LL || //CHN MSET
+             progId == 0x0004001000027000LL || //KOR MSET
+             progId == 0x0004001000028000LL) //TWN MSET
+            && CONFIG(PATCHVERSTRING))
+    {
+        static const u16 pattern[] = u"Ve";
+        static u16 *patch;
+        u32 patchSize = 0,
+        currentNand = BOOTCFG_NAND;
+
+        u16 customVerString[19];
+        loadCustomVerString(customVerString, &patchSize, currentNand);
+
+        if(patchSize != 0) patch = customVerString;
+        else
+        {
+            patchSize = 8;
+            u32 currentFirm = BOOTCFG_FIRM;
+
+            static u16 *verStringsNands[] = { u" Sys",
+                                              u" Emu",
+                                              u"Emu2",
+                                              u"Emu3",
+                                              u"Emu4" },
+
+                       *verStringsEmuSys[] = { u"EmuS",
+                                               u"Em2S",
+                                               u"Em3S",
+                                               u"Em4S" },
+
+                       *verStringsSysEmu[] = { u"SysE",
+                                               u"SyE2",
+                                               u"SyE3",
+                                               u"SyE4" };
+
+            patch = (currentFirm != 0) == (currentNand != 0) ? verStringsNands[currentNand] :
+                                          (!currentNand ? verStringsSysEmu[currentFirm - 1] : verStringsEmuSys[currentNand - 1]);
+        }
+
+        //Patch Ver. string
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern) - 2, 0,
+                patch,
+                patchSize, 1
+            )) goto error;
+    }
+
+    else if(progId == 0x0004013000008002LL) //NS
+    {
+        if(progVer > 4)
+        {
+            static const u8 pattern[] = {
+                0x0C, 0x18, 0xE1, 0xD8
+            },
+                            patch[] = {
+                0x0B, 0x18, 0x21, 0xC8
+            };
+
+            //Disable updates from foreign carts (makes carts region-free)
+            u32 ret = patchMemory(code, textSize,
+                          pattern,
+                          sizeof(pattern), 0,
+                          patch,
+                          sizeof(patch), 2
+                      );
+
+            if(ret == 0 || (ret == 1 && progVer > 0xB)) goto error;
+        }
+
+        if(LOADERFLAG(ISN3DS))
+        {
+            u32 cpuSetting = MULTICONFIG(NEWCPU);
+
+            if(cpuSetting != 0)
+            {
+                static const u8 pattern[] = {
+                    0x0C, 0x00, 0x94, 0x15
+                };
+
+                u32 *off = (u32 *)memsearch(code, pattern, textSize, sizeof(pattern));
+
+                if(off == NULL) goto error;
+
+                //Patch N3DS CPU Clock and L2 cache setting
+                *(off - 4) = *(off - 3);
+                *(off - 3) = *(off - 1);
+                memcpy(off - 1, off, 16);
+                *(off + 3) = 0xE3800000 | cpuSetting;
+            }
+        }
+    }
+
+    else if(progId == 0x0004013000001702LL) //CFG
+    {
+        static const u8 pattern[] = {
+            0x06, 0x46, 0x10, 0x48
+        },
+                        patch[] = {
+            0x00, 0x26
+        };
+
+        //Disable SecureInfo signature check
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern), 0,
+                patch,
+                sizeof(patch), 1
+            )) goto error;
+
+        if(secureInfoExists())
+        {
+            static const u16 pattern[] = u"Sec",
+                             patch[] = u"C";
+
+            //Use SecureInfo_C
+            if(patchMemory(code + ((textSize + 4095) & 0xFFFFF000), roSize,
+                   pattern,
+                   sizeof(pattern) - 2, 22,
+                   patch,
+                   sizeof(patch) - 2, 2
+               ) != 2) goto error;
+        }
+    }
+
+    else if(progId == 0x0004013000003702LL && progVer > 0) //RO
+    {
+        static const u8 pattern[] = {
+            0x20, 0xA0, 0xE1, 0x8B
+        },
+                        pattern2[] = {
+            0xE1, 0x30, 0x40, 0x2D
+        },
+                        pattern3[] = {
+            0x2D, 0xE9, 0x01, 0x70
+        },
+                        patch[] = {
+            0x00, 0x00, 0xA0, 0xE3, 0x1E, 0xFF, 0x2F, 0xE1 //mov r0, #0; bx lr
+        };
+
+        //Disable CRR0 signature (RSA2048 with SHA256) check and CRO0/CRR0 SHA256 hash checks (section hashes, and hash table)
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern), -9,
+                patch,
+                sizeof(patch), 1
+            ) ||
+           !patchMemory(code, textSize,
+                pattern2,
+                sizeof(pattern2), 1,
+                patch,
+                sizeof(patch), 1
+            ) ||
+           !patchMemory(code, textSize,
+                pattern3,
+                sizeof(pattern3), -2,
+                patch,
+                sizeof(patch), 1
+            )) goto error;
+    }
+
+    else if(progId == 0x0004003000008A02LL && CONFIG(ENABLEEXCEPTIONHANDLERS) && !CONFIG(PATCHUNITINFO)) //ErrDisp
+    {
+        static const u8 pattern[] = {
+            0x00, 0xD0, 0xE5, 0xDB
+        },
+                        pattern2[] = {
+            0x14, 0x00, 0xD0, 0xE5, 0x01
+        },
+                        patch[] = {
+            0x00, 0x00, 0xA0, 0xE3
+        };
+
+        //Patch UNITINFO checks to make ErrDisp more verbose
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern), -1,
+                patch,
+                sizeof(patch), 1
+            ) ||
+           patchMemory(code, textSize,
+               pattern2,
+               sizeof(pattern2), 0,
+               patch,
+               sizeof(patch), 3
+           ) != 3) goto error;
+    }
+
+    else if(progId == 0x0004013000002802LL) //DLP
+    {
+        static const u8 pattern[] = {
+            0x0C, 0xAC, 0xC0, 0xD8
+        },
+                        patch[] = {
+            0x00, 0x00, 0x00, 0x00
+        };
+
+        //Patch DLP region checks
+        if(!patchMemory(code, textSize,
+                pattern,
+                sizeof(pattern), 0,
+                patch,
+                sizeof(patch), 1
+            )) goto error;
+    }
+
+    if(CONFIG(PATCHGAMES))
+    {
+        if(!loadTitleCodeSection(progId, code, size) ||
+           !applyCodeIpsPatch(progId, code, size)) goto error;
+
+        if((u32)((progId >> 0x20) & 0xFFFFFFEDULL) == 0x00040000)
+        {
+            u8 regionId = 0xFF,
+               languageId;
+
+            if(!loadTitleLocaleConfig(progId, &regionId, &languageId) ||
+               !patchLayeredFs(progId, code, size, textSize, roSize, dataSize, roAddress, dataAddress)) goto error;
+
+            if(regionId != 0xFF)
+            {
+                u32 CFGUHandleOffset;
+                u8 *CFGU_GetConfigInfoBlk2_endPos = getCfgOffsets(code, textSize, &CFGUHandleOffset);
+
+                if(CFGU_GetConfigInfoBlk2_endPos == NULL ||
+                   !patchCfgGetLanguage(code, textSize, languageId, CFGU_GetConfigInfoBlk2_endPos)) goto error;
+
+                patchCfgGetRegion(code, textSize, regionId, CFGUHandleOffset);
+            }
+        }
+    }
+
+    return;
+
+error:
+    svcBreak(USERBREAK_ASSERT);
+    while(true);
+}

sysmodules/loader/source/patcher.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <3ds/types.h>
+
+#define MAKE_BRANCH(src,dst)      (0xEA000000 | ((u32)((((u8 *)(dst) - (u8 *)(src)) >> 2) - 2) & 0xFFFFFF))
+#define MAKE_BRANCH_LINK(src,dst) (0xEB000000 | ((u32)((((u8 *)(dst) - (u8 *)(src)) >> 2) - 2) & 0xFFFFFF))
+
+#define CONFIG(a)        (((info.config >> (a + 17)) & 1) != 0)
+#define MULTICONFIG(a)   ((info.config >> (a * 2 + 7)) & 3)
+#define BOOTCONFIG(a, b) ((info.config >> a) & b)
+#define LOADERFLAG(a)    ((info.flags >> (a + 4)) & 1) != 0
+
+#define BOOTCFG_NAND         BOOTCONFIG(0, 7)
+#define BOOTCFG_FIRM         BOOTCONFIG(3, 7)
+#define BOOTCFG_NOFORCEFLAG  BOOTCONFIG(6, 1)
+
+enum multiOptions
+{
+    DEFAULTEMU = 0,
+    BRIGHTNESS,
+    SPLASH,
+    PIN,
+    NEWCPU
+};
+
+enum singleOptions
+{
+    AUTOBOOTEMU = 0,
+    USEEMUFIRM,
+    LOADEXTFIRMSANDMODULES,
+    PATCHGAMES,
+    PATCHVERSTRING,
+    SHOWGBABOOT,
+    PATCHACCESS,
+    PATCHUNITINFO,
+    ENABLEEXCEPTIONHANDLERS
+};
+
+enum flags
+{
+    ISN3DS = 0,
+    ISSAFEMODE,
+    ISSDMODE
+};
+
+void patchCode(u64 progId, u16 progVer, u8 *code, u32 size, u32 textSize, u32 roSize, u32 dataSize, u32 roAddress, u32 dataAddress);

sysmodules/loader/source/pxipm.c

@@ -0,0 +1,74 @@
+#include <3ds.h>
+#include <string.h>
+#include "pxipm.h"
+#include "srvsys.h"
+
+static Handle pxipmHandle;
+static int pxipmRefCount;
+
+Result pxipmInit(void)
+{
+  Result ret = 0;
+
+  if (AtomicPostIncrement(&pxipmRefCount)) return 0;
+
+  ret = srvSysGetServiceHandle(&pxipmHandle, "PxiPM");
+
+  if (R_FAILED(ret)) AtomicDecrement(&pxipmRefCount);
+  return ret;
+}
+
+void pxipmExit(void)
+{
+  if (AtomicDecrement(&pxipmRefCount)) return;
+  svcCloseHandle(pxipmHandle);
+}
+
+Result PXIPM_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x2,8,0); // 0x20200
+  memcpy(&cmdbuf[1], &title->programId, sizeof(u64));
+  *(u8 *)&cmdbuf[3] = title->mediaType;
+  memcpy(((u8 *)&cmdbuf[3])+1, &title->padding, 7);
+  memcpy(&cmdbuf[5], &update->programId, sizeof(u64));
+  *(u8 *)&cmdbuf[7] = update->mediaType;
+  memcpy(((u8 *)&cmdbuf[7])+1, &update->padding, 7);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(pxipmHandle))) return ret;
+  *prog_handle = *(u64*)&cmdbuf[2];
+
+  return cmdbuf[1];
+}
+
+Result PXIPM_GetProgramInfo(exheader_header *exheader, u64 prog_handle)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x1,2,2); // 0x10082
+  cmdbuf[1] = (u32) (prog_handle);
+  cmdbuf[2] = (u32) (prog_handle >> 32);
+  cmdbuf[3] = (0x400 << 8) | 0x4;
+  cmdbuf[4] = (u32) exheader;
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(pxipmHandle))) return ret;
+
+  return cmdbuf[1];
+}
+
+Result PXIPM_UnregisterProgram(u64 prog_handle)
+{
+  u32 *cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x3,2,0); // 0x30080
+  cmdbuf[1] = (u32) (prog_handle);
+  cmdbuf[2] = (u32) (prog_handle >> 32);
+
+  Result ret = 0;
+  if(R_FAILED(ret = svcSendSyncRequest(pxipmHandle))) return ret;
+
+  return cmdbuf[1];
+}

sysmodules/loader/source/pxipm.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <3ds/types.h>
+#include "exheader.h"
+
+Result pxipmInit(void);
+void pxipmExit(void);
+Result PXIPM_RegisterProgram(u64 *prog_handle, FS_ProgramInfo *title, FS_ProgramInfo *update);
+Result PXIPM_GetProgramInfo(exheader_header *exheader, u64 prog_handle);
+Result PXIPM_UnregisterProgram(u64 prog_handle);

sysmodules/loader/source/srvsys.c

@@ -0,0 +1,154 @@
+#include <3ds.h>
+#include <string.h>
+#include "srvsys.h"
+
+static Handle srvHandle;
+static int srvRefCount;
+static RecursiveLock initLock;
+static int initLockinit = 0;
+
+Result srvSysInit()
+{
+  Result rc = 0;
+
+  if (!initLockinit)
+  {
+    RecursiveLock_Init(&initLock);
+  }
+
+  RecursiveLock_Lock(&initLock);
+
+  if (srvRefCount > 0)
+  {
+    RecursiveLock_Unlock(&initLock);
+    return MAKERESULT(RL_INFO, RS_NOP, 25, RD_ALREADY_INITIALIZED);
+  }
+
+  while (1)
+  {
+    rc = svcConnectToPort(&srvHandle, "srv:");
+    if (R_LEVEL(rc) != RL_PERMANENT || 
+        R_SUMMARY(rc) != RS_NOTFOUND || 
+        R_DESCRIPTION(rc) != RD_NOT_FOUND
+       ) break;
+    svcSleepThread(500000);
+  }
+  if (R_SUCCEEDED(rc))
+  {
+    rc = srvSysRegisterClient();
+    srvRefCount++;
+  }
+
+  RecursiveLock_Unlock(&initLock);
+  return rc;
+}
+
+Result srvSysRegisterClient(void)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x1,0,2); // 0x10002
+  cmdbuf[1] = IPC_Desc_CurProcessHandle();
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  return cmdbuf[1];
+}
+
+Result srvSysExit()
+{
+  Result rc;
+  RecursiveLock_Lock(&initLock);
+
+  if (srvRefCount > 1)
+  {
+    srvRefCount--;
+    RecursiveLock_Unlock(&initLock);
+    return MAKERESULT(RL_INFO, RS_NOP, 25, RD_BUSY);
+  }
+
+  if (srvHandle != 0) svcCloseHandle(srvHandle);
+  else svcBreak(USERBREAK_ASSERT);
+  rc = (Result)srvHandle; // yeah, I think this is a benign bug
+  srvHandle = 0;
+  srvRefCount--;
+  RecursiveLock_Unlock(&initLock);
+  return rc;
+}
+
+Result srvSysGetServiceHandle(Handle* out, const char* name)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x5,4,0); // 0x50100
+  strncpy((char*) &cmdbuf[1], name,8);
+  cmdbuf[3] = strlen(name);
+  cmdbuf[4] = 0x0;
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  if(out) *out = cmdbuf[3];
+
+  return cmdbuf[1];
+}
+
+Result srvSysEnableNotification(Handle* semaphoreOut)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x2,0,0);
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  if(semaphoreOut) *semaphoreOut = cmdbuf[3];
+
+  return cmdbuf[1];
+}
+
+Result srvSysReceiveNotification(u32* notificationIdOut)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0xB,0,0); // 0xB0000
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  if(notificationIdOut) *notificationIdOut = cmdbuf[2];
+
+  return cmdbuf[1];
+}
+
+Result srvSysRegisterService(Handle* out, const char* name, int maxSessions)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x3,4,0); // 0x30100
+  strncpy((char*) &cmdbuf[1], name,8);
+  cmdbuf[3] = strlen(name);
+  cmdbuf[4] = maxSessions;
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  if(out) *out = cmdbuf[3];
+
+  return cmdbuf[1];
+}
+
+Result srvSysUnregisterService(const char* name)
+{
+  Result rc = 0;
+  u32* cmdbuf = getThreadCommandBuffer();
+
+  cmdbuf[0] = IPC_MakeHeader(0x4,3,0); // 0x400C0
+  strncpy((char*) &cmdbuf[1], name,8);
+  cmdbuf[3] = strlen(name);
+
+  if(R_FAILED(rc = svcSendSyncRequest(srvHandle)))return rc;
+
+  return cmdbuf[1];
+}

sysmodules/loader/source/srvsys.h

@@ -0,0 +1,47 @@
+/**
+ * @file srv.h
+ * @brief Service API.
+ */
+#pragma once
+
+/// Initializes the service API.
+Result srvSysInit(void);
+
+/// Exits the service API.
+Result srvSysExit(void);
+
+/**
+ * @brief Retrieves a service handle, retrieving from the environment handle list if possible.
+ * @param out Pointer to write the handle to.
+ * @param name Name of the service.
+ */
+Result srvSysGetServiceHandle(Handle* out, const char* name);
+
+/// Registers the current process as a client to the service API.
+Result srvSysRegisterClient(void);
+
+/**
+ * @brief Enables service notificatios, returning a notification semaphore.
+ * @param semaphoreOut Pointer to output the notification semaphore to.
+ */
+Result srvSysEnableNotification(Handle* semaphoreOut);
+
+/**
+ * @brief Receives a notification.
+ * @param notificationIdOut Pointer to output the ID of the received notification to.
+ */
+Result srvSysReceiveNotification(u32* notificationIdOut);
+
+/**
+ * @brief Registers the current process as a service.
+ * @param out Pointer to write the service handle to.
+ * @param name Name of the service.
+ * @param maxSessions Maximum number of sessions the service can handle.
+ */
+Result srvSysRegisterService(Handle* out, const char* name, int maxSessions);
+
+/**
+ * @brief Unregisters the current process as a service.
+ * @param name Name of the service.
+ */
+Result srvSysUnregisterService(const char* name);

sysmodules/loader/source/strings.c

@@ -0,0 +1,20 @@
+#include "strings.h"
+
+size_t strnlen(const char *string, size_t maxlen)
+{
+    size_t size;
+
+    for(size = 0; *string && size < maxlen; string++, size++);
+
+    return size;
+}
+
+void progIdToStr(char *strEnd, u64 progId)
+{
+    while(progId > 0)
+    {
+        static const char hexDigits[] = "0123456789ABCDEF";
+        *strEnd-- = hexDigits[(u32)(progId & 0xF)];
+        progId >>= 4;
+    }
+}

sysmodules/loader/source/strings.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <3ds/types.h>
+
+size_t strnlen(const char *string, size_t maxlen);
+void progIdToStr(char *strEnd, u64 progId);