npdmtool: don't error with missing debug flags, error with multiple set (#50)

Version field was incorrectly labeled "process_category". This is now supported (and defaults to 0 if not present on npdm, 1 if not present on kip). process_category is alias.

Support was added for mesosphere large-address map extension (these bits are reserved in official OS).

Support was added for specifying the signature key generation, which determines modulus used to verify ACID.

Support was added for system call capabilities in range [0x80, 0xBF], which kernel allows since 11.0.0.

"title_id" (and min/max) were renamed to program_id. If program_id not present, title_id used as alias.

configure.ac

@@ -2,7 +2,7 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ(2.61)
-AC_INIT([switch-tools],[1.9.0],[https://github.com/switchbrew/switch-tools/issues])
+AC_INIT([switch-tools],[1.13.1],[https://github.com/switchbrew/switch-tools/issues])
 AC_CONFIG_SRCDIR([src/build_pfs0.c])
 
 AM_INIT_AUTOMAKE([subdir-objects])

src/elf2kip.c

@@ -9,11 +9,6 @@
 #include "blz.h"
 #include "elf64.h"
 
-typedef uint64_t u64;
-typedef uint32_t u32;
-typedef uint16_t u16;
-typedef uint8_t u8;
-
 typedef struct {
     u32 DstOff;
     u32 DecompSz;
@@ -24,8 +19,8 @@ typedef struct {
 typedef struct {
     u8  Magic[4];
     u8  Name[0xC];
-    u64 TitleId;
-    u32 ProcessCategory;
+    u64 ProgramId;
+    u32 Version;
     u8  MainThreadPriority;
     u8  DefaultCpuId;
     u8  Unk;
@@ -190,6 +185,32 @@ int cJSON_GetU64FromObjectValue(const cJSON *config, u64 *out) {
     }
 }
 
+int cJSON_GetU32(const cJSON *obj, const char *field, u32 *out) {
+    const cJSON *config = cJSON_GetObjectItemCaseSensitive(obj, field);
+    if (cJSON_IsString(config) && (config->valuestring != NULL)) {
+        char *endptr = NULL;
+        *out = strtoul(config->valuestring, &endptr, 16);
+        if (config->valuestring == endptr) {
+            fprintf(stderr, "Failed to get %s (empty string)\n", field);
+            return 0;
+        } else if (errno == ERANGE) {
+            fprintf(stderr, "Failed to get %s (value out of range)\n", field);
+            return 0;
+        } else if (errno == EINVAL) {
+            fprintf(stderr, "Failed to get %s (not base16 string)\n", field);
+            return 0;
+        } else if (errno) {
+            fprintf(stderr, "Failed to get %s (unknown error)\n", field);
+            return 0;
+        } else {
+            return 1;
+        }
+    } else {
+        fprintf(stderr, "Failed to get %s (field not present).\n", field);
+        return 0;
+    }
+}
+
 int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
     const cJSON *capability = NULL;
     const cJSON *capabilities = NULL;
@@ -214,8 +235,8 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
         goto PARSE_CAPS_END;
     }
 
-    /* Parse title_id. */
-    if (!cJSON_GetU64(npdm_json, "title_id", &kip_hdr->TitleId)) {
+    /* Parse program_id (or deprecated title_id). */
+    if (!cJSON_GetU64(npdm_json, "program_id", &kip_hdr->ProgramId) && !cJSON_GetU64(npdm_json, "title_id", &kip_hdr->ProgramId)) {
         status = 0;
         goto PARSE_CAPS_END;
     }
@@ -231,6 +252,17 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
         }
     }
 
+    /* Parse immortality. */
+    /* This field is optional, and defaults to true (set before this function is called). */
+    int immortal = 1;
+    if (cJSON_GetBooleanOptional(npdm_json, "immortal", &immortal)) {
+        if (immortal) {
+            kip_hdr->Flags |= 0x40;
+        } else {
+            kip_hdr->Flags &= ~0x40;
+        }
+    }
+
     /* Parse main_thread_stack_size. */
     u64 stack_size = 0;
     if (!cJSON_GetU64(npdm_json, "main_thread_stack_size", &stack_size)) {
@@ -253,9 +285,8 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
         status = 0;
         goto PARSE_CAPS_END;
     }
-    if (!cJSON_GetU8(npdm_json, "process_category", (u8 *)&kip_hdr->ProcessCategory)) {
-        status = 0;
-        goto PARSE_CAPS_END;
+    if (!cJSON_GetU32(npdm_json, "version", &kip_hdr->Version) && !cJSON_GetU32(npdm_json, "process_category", &kip_hdr->Version)) { // optional
+        kip_hdr->Version = 1;
     }
 
     /* Parse capabilities. */
@@ -310,13 +341,17 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
                 status = 0;
                 goto PARSE_CAPS_END;
             }
+
+            u8 real_highest_prio = (lowest_prio < highest_prio) ? lowest_prio : highest_prio;
+            u8 real_lowest_prio  = (lowest_prio > highest_prio) ? lowest_prio : highest_prio;
+
             desc = highest_cpu;
             desc <<= 8;
             desc |= lowest_cpu;
             desc <<= 6;
-            desc |= (lowest_prio & 0x3F);
+            desc |= (real_highest_prio & 0x3F);
             desc <<= 6;
-            desc |= (highest_prio & 0x3F);
+            desc |= (real_lowest_prio & 0x3F);
             kip_hdr->Capabilities[cur_cap++] = (u32)((desc << 4) | (0x0007));
         } else if (!strcmp(type_str, "syscalls")) {
             if (!cJSON_IsObject(value)) {
@@ -325,7 +360,7 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
                 goto PARSE_CAPS_END;
             }
             u32 num_descriptors;
-            u32 descriptors[6] = {0}; /* alignup(0x80/0x18); */
+            u32 descriptors[8] = {0}; /* alignup(0xC0/0x18); */
             char field_name[8] = {0};
             const cJSON *cur_syscall = NULL;
             u64 syscall_value = 0;
@@ -338,14 +373,14 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
                     goto PARSE_CAPS_END;
                 }
 
-                if (syscall_value >= 0x80) {
-                    fprintf(stderr, "Error: All syscall entries must be numbers in [0, 0x7F]\n");
+                if (syscall_value >= 0xC0) {
+                    fprintf(stderr, "Error: All syscall entries must be numbers in [0, 0xBF]\n");
                     status = 0;
                     goto PARSE_CAPS_END;
                 }
                 descriptors[syscall_value / 0x18] |= (1UL << (syscall_value % 0x18));
             }
-            for (unsigned int i = 0; i < 6; i++) {
+            for (unsigned int i = 0; i < 8; i++) {
                 if (descriptors[i]) {
                     if (cur_cap + 1 > 0x20) {
                         fprintf(stderr, "Error: Too many capabilities!\n");
@@ -382,7 +417,8 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
             desc |= is_ro << 24;
             kip_hdr->Capabilities[cur_cap++] = (u32)((desc << 7) | (0x003F));
 
-            desc = (u32)((map_size >> 12) & 0x00FFFFFFULL);
+            desc = (u32)((map_size >> 12) & 0x000FFFFFULL);
+            desc |= (u32)(((map_address >> 36) & 0xFULL) << 20);
             is_io ^= 1;
             desc |= is_io << 24;
             kip_hdr->Capabilities[cur_cap++] = (u32)((desc << 7) | (0x003F));
@@ -518,6 +554,7 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
             }
             int allow_debug = 0;
             int force_debug = 0;
+            int force_debug_prod = 0;
             if (!cJSON_GetBoolean(value, "allow_debug", &allow_debug)) {
                 status = 0;
                 goto PARSE_CAPS_END;
@@ -526,7 +563,11 @@ int ParseKipConfiguration(const char *json, KipHeader *kip_hdr) {
                 status = 0;
                 goto PARSE_CAPS_END;
             }
-            desc = (allow_debug & 1) | ((force_debug & 1) << 1);
+            if (!cJSON_GetBoolean(value, "force_debug_prod", &force_debug_prod)) {
+                status = 0;
+                goto PARSE_CAPS_END;
+            }
+            desc = (allow_debug & 1) | ((force_debug_prod & 1) << 1) | ((force_debug & 1) << 2);
             kip_hdr->Capabilities[cur_cap++] = (u32)((desc << 17) | (0xFFFF));
         } else {
             fprintf(stderr, "Error: unknown capability %s\n", type_str);
@@ -553,7 +594,7 @@ int main(int argc, char* argv[]) {
 
     KipHeader kip_hdr = {0};
     memcpy(kip_hdr.Magic, "KIP1", 4);
-    kip_hdr.Flags = 0x3F;
+    kip_hdr.Flags = 0x7F;
 
     if (sizeof(KipHeader) != 0x100) {
         fprintf(stderr, "Bad compile environment!\n");

src/elf2nro.c

@@ -8,10 +8,6 @@
 #include "elf64.h"
 #include "romfs.h"
 
-typedef uint64_t u64;
-typedef uint32_t u32;
-typedef uint8_t u8;
-
 typedef struct {
     u32 FileOff;
     u32 Size;
@@ -25,9 +21,9 @@ typedef struct {
 
 typedef struct {
     u8  Magic[4];
-    u32 Unk1;
+    u32 version;
     u32 size;
-    u32 Unk2;
+    u32 flags;
     NsoSegment Segments[3];
     u32 bssSize;
     u32 Unk3;
@@ -82,9 +78,10 @@ int main(int argc, char* argv[]) {
         fprintf(stderr, "--nacp=<control.nacp> Embeds control.nacp into the output file.\n");
         fprintf(stderr, "--romfs=<image> Embeds RomFS into the output file.\n");
         fprintf(stderr, "--romfsdir=<directory> Builds and embeds RomFS into the output file.\n");
+        fprintf(stderr, "--alignedheader Sets the \"AlignedHeader\" flag in the output file.\n");
         return EXIT_FAILURE;
     }
-    
+
     NroStart nro_start;
     memset(&nro_start, 0, sizeof(nro_start));
 
@@ -106,18 +103,20 @@ int main(int argc, char* argv[]) {
 
     int argi;
     char* icon_path = NULL, *nacp_path = NULL, *romfs_path = NULL, *romfs_dir_path = NULL;
+    u32 aligned_header = 0;
     for (argi=3; argi<argc; argi++) {
         if (strncmp(argv[argi], "--icon=", 7)==0) icon_path = &argv[argi][7];
         if (strncmp(argv[argi], "--nacp=", 7)==0) nacp_path = &argv[argi][7];
         if (strncmp(argv[argi], "--romfs=", 8)==0) romfs_path = &argv[argi][8];
         if (strncmp(argv[argi], "--romfsdir=", 11)==0) romfs_dir_path = &argv[argi][11];
+        if (strncmp(argv[argi], "--alignedheader", 15)==0) aligned_header = 1;
     }
-    
+
     if (romfs_dir_path != NULL && romfs_path != NULL) {
         fprintf(stderr, "Cannot have a RomFS and a RomFS Directory at the same time!\n");
         return EXIT_FAILURE;
     }
-    
+
     if (elf_len < sizeof(Elf64_Ehdr)) {
         fprintf(stderr, "Input file doesn't fit ELF header!\n");
         return EXIT_FAILURE;
@@ -158,7 +157,7 @@ int main(int argc, char* argv[]) {
             fprintf(stderr, "Invalid ELF: expected 3 loadable phdrs and a bss!\n");
             return EXIT_FAILURE;
         }
-        
+
         // .bss is special
         if (i == 3) {
             tmpsize = (phdr->p_filesz + 0xFFF) & ~0xFFF;
@@ -178,13 +177,13 @@ int main(int argc, char* argv[]) {
             fprintf(stderr, "Out of memory!\n");
             return EXIT_FAILURE;
         }
-        
+
         memcpy(buf[i], &elf[phdr->p_offset], phdr->p_filesz);
 
         file_off += nro_hdr.Segments[i].Size;
         file_off = (file_off + 0xFFF) & ~0xFFF;
     }
-    
+
     /* Iterate over sections to find build id. */
     size_t cur_sect_hdr_ofs = hdr->e_shoff;
     for (unsigned int i = 0; i < hdr->e_shnum; i++) {
@@ -210,9 +209,12 @@ int main(int argc, char* argv[]) {
         fprintf(stderr, "Failed to open output file!\n");
         return EXIT_FAILURE;
     }
-    
+
     nro_hdr.size = file_off;
 
+    nro_hdr.version = 0;
+    nro_hdr.flags   = (aligned_header << 0);
+
     // TODO check retvals
 
     for (i=0; i<3; i++)
@@ -274,7 +276,7 @@ int main(int argc, char* argv[]) {
         asset_hdr.romfs.offset = tmp_off;
         asset_hdr.romfs.size = romfs_len;
         tmp_off+= romfs_len;
-        
+
     } else if (romfs_dir_path) {
         asset_hdr.romfs.offset = tmp_off;
         asset_hdr.romfs.size = build_romfs_by_path_into_file(romfs_dir_path, out, file_off + tmp_off);

src/npdmtool.c

@@ -45,7 +45,7 @@ typedef struct {
 typedef struct {
     u32 Magic;
     u8 _0x4[0xC];
-    u64 TitleId;
+    u64 ProgramId;
     u64 _0x18;
     u32 FahOffset;
     u32 FahSize;
@@ -63,8 +63,8 @@ typedef struct {
     u32 Size;
     u32 _0x208;
     u32 Flags;
-    u64 TitleIdRangeMin;
-    u64 TitleIdRangeMax;
+    u64 ProgramIdRangeMin;
+    u64 ProgramIdRangeMax;
     u32 FacOffset;
     u32 FacSize;
     u32 SacOffset;
@@ -76,7 +76,7 @@ typedef struct {
 
 typedef struct {
     u32 Magic;
-    u32 _0x4;
+    u32 SignatureKeyGeneration;
     u32 _0x8;
     u8 MmuFlags;
     u8 _0xD;
@@ -84,7 +84,7 @@ typedef struct {
     u8 DefaultCpuId;
     u32 _0x10;
     u32 SystemResourceSize;
-    u32 ProcessCategory;
+    u32 Version;
     u32 MainThreadStackSize;
     char Name[0x10];
     char ProductCode[0x10];
@@ -345,10 +345,11 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
 
     cJSON_GetU32(npdm_json, "system_resource_size", &header.SystemResourceSize); // optional
 
-    if (!cJSON_GetU8(npdm_json, "process_category", (u8 *)&header.ProcessCategory)) {
-        status = 0;
-        goto NPDM_BUILD_END;
+    /* Get version (deprecated name "process_category"). */
+    if (!cJSON_GetU32(npdm_json, "version", &header.Version) && !cJSON_GetU32(npdm_json, "process_category", &header.Version)) { // optional
+        header.Version = 0;
     }
+
     if (!cJSON_GetU8(npdm_json, "address_space_type", (u8 *)&header.MmuFlags)) {
         status = 0;
         goto NPDM_BUILD_END;
@@ -362,11 +363,33 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
     }
     header.MmuFlags |= is_64_bit;
 
+    int optimize_memory_allocation; // optional
+    if (cJSON_GetBoolean(npdm_json, "optimize_memory_allocation", &optimize_memory_allocation)) {
+        header.MmuFlags |= ((optimize_memory_allocation & 1) << 4);
+    }
+
     int disable_device_address_space_merge; // optional
     if (cJSON_GetBoolean(npdm_json, "disable_device_address_space_merge", &disable_device_address_space_merge)) {
         header.MmuFlags |= ((disable_device_address_space_merge & 1) << 5);
     }
 
+    int enable_alias_region_extra_size; // optional
+    if (cJSON_GetBoolean(npdm_json, "enable_alias_region_extra_size", &enable_alias_region_extra_size)) {
+        header.MmuFlags |= ((enable_alias_region_extra_size & 1) << 6);
+    }
+
+    int prevent_code_reads; // optional
+    if (cJSON_GetBoolean(npdm_json, "prevent_code_reads", &prevent_code_reads)) {
+        header.MmuFlags |= ((prevent_code_reads & 1) << 7);
+    }
+
+    u8 signature_key_generation; // optional
+    if (cJSON_GetU8(npdm_json, "signature_key_generation", &signature_key_generation)) {
+        header.SignatureKeyGeneration = signature_key_generation;
+    } else {
+        header.SignatureKeyGeneration = 0;
+    }
+
     /* ACID. */
     memset(acid->Signature, 0, sizeof(acid->Signature));
     memset(acid->Modulus, 0, sizeof(acid->Modulus));
@@ -384,19 +407,19 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
     }
     acid->Flags |= (pool_partition & 3) << 2;
 
-    if (!cJSON_GetU64(npdm_json, "title_id_range_min", &acid->TitleIdRangeMin)) {
+    if (!cJSON_GetU64(npdm_json, "program_id_range_min", &acid->ProgramIdRangeMin) && !cJSON_GetU64(npdm_json, "title_id_range_min", &acid->ProgramIdRangeMin)) {
         status = 0;
         goto NPDM_BUILD_END;
     }
-    if (!cJSON_GetU64(npdm_json, "title_id_range_max", &acid->TitleIdRangeMax)) {
+    if (!cJSON_GetU64(npdm_json, "program_id_range_max", &acid->ProgramIdRangeMax) && !cJSON_GetU64(npdm_json, "title_id_range_max", &acid->ProgramIdRangeMax)) {
         status = 0;
         goto NPDM_BUILD_END;
     }
 
     /* ACI0. */
     aci0->Magic = MAGIC_ACI0; /* "ACI0" */
-    /* Parse title_id. */
-    if (!cJSON_GetU64(npdm_json, "title_id", &aci0->TitleId)) {
+    /* Parse program_id (or deprecated title_id). */
+    if (!cJSON_GetU64(npdm_json, "program_id", &aci0->ProgramId) && !cJSON_GetU64(npdm_json, "title_id", &aci0->ProgramId)) {
         status = 0;
         goto NPDM_BUILD_END;
     }
@@ -458,18 +481,33 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
     sdois = cJSON_GetObjectItemCaseSensitive(fsaccess, "save_data_owner_ids");
     if (cJSON_IsArray(sdois)) {
         u32 *count = (u32 *)((u8 *)fah + fah->SdoiOffset);
-        u64 *id = (u64 *)((u8 *)count + sizeof(u32));
         cJSON_ArrayForEach(sdoi, sdois) {
-            if (!cJSON_GetU64FromObjectValue(sdoi, id)) {
+            if (!cJSON_IsObject(sdoi)) {
                 status = 0;
                 goto NPDM_BUILD_END;
             }
-            ++id;
             ++(*count);
         }
 
+        u8 *accessibility = (u8 *)count + sizeof(u32);
+        u64 *id = (u64 *)(accessibility + (((*count) + 3ULL) & ~3ULL));
+
+        cJSON_ArrayForEach(sdoi, sdois) {
+            if (!cJSON_GetU8(sdoi, "accessibility", accessibility)) {
+                status = 0;
+                goto NPDM_BUILD_END;
+            }
+            if (!cJSON_GetU64(sdoi, "id", id)) {
+                status = 0;
+                goto NPDM_BUILD_END;
+            }
+
+            ++accessibility;
+            ++id;
+        }
+
         if (*count > 0) {
-            fah->SdoiSize = sizeof(u32) + sizeof(u64) * (*count);
+            fah->SdoiSize = sizeof(u32) + sizeof(u8) * ((((*count) + 3ULL) & ~3ULL)) + sizeof(u64) * (*count);
         }
     }
 
@@ -618,13 +656,17 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
                 status = 0;
                 goto NPDM_BUILD_END;
             }
+
+            u8 real_highest_prio = (lowest_prio < highest_prio) ? lowest_prio : highest_prio;
+            u8 real_lowest_prio  = (lowest_prio > highest_prio) ? lowest_prio : highest_prio;
+
             desc = highest_cpu;
             desc <<= 8;
             desc |= lowest_cpu;
             desc <<= 6;
-            desc |= (lowest_prio & 0x3F);
+            desc |= (real_highest_prio & 0x3F);
             desc <<= 6;
-            desc |= (highest_prio & 0x3F);
+            desc |= (real_lowest_prio & 0x3F);
             caps[cur_cap++] = (u32)((desc << 4) | (0x0007));
         } else if (!strcmp(type_str, "syscalls")) {
             if (!cJSON_IsObject(value)) {
@@ -633,7 +675,7 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
                 goto NPDM_BUILD_END;
             }
             u32 num_descriptors;
-            u32 descriptors[6] = {0}; /* alignup(0x80/0x18); */
+            u32 descriptors[8] = {0}; /* alignup(0xC0/0x18); */
             char field_name[8] = {0};
             const cJSON *cur_syscall = NULL;
             u64 syscall_value = 0;
@@ -646,14 +688,14 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
                     goto NPDM_BUILD_END;
                 }
 
-                if (syscall_value >= 0x80) {
-                    fprintf(stderr, "Error: All syscall entries must be numbers in [0, 0x7F]\n");
+                if (syscall_value >= 0xC0) {
+                    fprintf(stderr, "Error: All syscall entries must be numbers in [0, 0xBF]\n");
                     status = 0;
                     goto NPDM_BUILD_END;
                 }
                 descriptors[syscall_value / 0x18] |= (1UL << (syscall_value % 0x18));
             }
-            for (unsigned int i = 0; i < 6; i++) {
+            for (unsigned int i = 0; i < 8; i++) {
                 if (descriptors[i]) {
                     desc = descriptors[i] | (i << 24);
                     caps[cur_cap++] = (u32)((desc << 5) | (0x000F));
@@ -680,7 +722,8 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
             desc |= is_ro << 24;
             caps[cur_cap++] = (u32)((desc << 7) | (0x003F));
 
-            desc = (u32)((map_size >> 12) & 0x00FFFFFFULL);
+            desc = (u32)((map_size >> 12) & 0x000FFFFFULL);
+            desc |= (u32)(((map_address >> 36) & 0xFULL) << 20);
             is_io ^= 1;
             desc |= is_io << 24;
             caps[cur_cap++] = (u32)((desc << 7) | (0x003F));
@@ -786,15 +829,16 @@ int CreateNpdm(const char *json, void **dst, u32 *dst_size) {
             }
             int allow_debug = 0;
             int force_debug = 0;
-            if (!cJSON_GetBoolean(value, "allow_debug", &allow_debug)) {
+            int force_debug_prod = 0;
+            cJSON_GetBoolean(value, "allow_debug", &allow_debug);
+            cJSON_GetBoolean(value, "force_debug", &force_debug);
+            cJSON_GetBoolean(value, "force_debug_prod", &force_debug_prod);
+            if ( allow_debug + force_debug + force_debug_prod > 1 ) {
+                fprintf(stderr, "Only one of allow_debug, force_debug, or force_debug_prod can be set!\n");
                 status = 0;
                 goto NPDM_BUILD_END;
             }
-            if (!cJSON_GetBoolean(value, "force_debug", &force_debug)) {
-                status = 0;
-                goto NPDM_BUILD_END;
-            }
-            desc = (allow_debug & 1) | ((force_debug & 1) << 1);
+            desc = (allow_debug & 1) | ((force_debug_prod & 1) << 1) | ((force_debug & 1) << 2);
             caps[cur_cap++] = (u32)((desc << 17) | (0xFFFF));
         }
     }

src/romfs.c

@@ -96,11 +96,11 @@ uint32_t calc_path_hash(uint32_t parent, const unsigned char *path, uint32_t sta
         hash = (hash >> 5) | (hash << 27);
         hash ^= path[start + i];
     }
-        
+
     return hash;
 }
 
-uint32_t align(uint32_t offset, uint32_t alignment) { 
+uint32_t align(uint32_t offset, uint32_t alignment) {
     uint32_t mask = ~(alignment-1);
 
     return (offset + (alignment-1)) & mask;
@@ -134,47 +134,47 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
     romfs_fent_ctx_t *cur_file = NULL;
     filepath_t cur_path;
     filepath_t cur_sum_path;
-    
+
     os_stat64_t cur_stats;
-    
+
     if ((dir = os_opendir(parent->sum_path.os_path)) == NULL) {
         fprintf(stderr, "Failed to open directory %s!\n", parent->sum_path.char_path);
         exit(EXIT_FAILURE);
     }
-    
+
     while ((cur_dirent = os_readdir(dir))) {
         filepath_init(&cur_path);
         filepath_set(&cur_path, "");
         filepath_os_append(&cur_path, cur_dirent->d_name);
-        
+
         if (strcmp(cur_path.char_path, "/.") == 0 || strcmp(cur_path.char_path, "/..") == 0) {
             /* Special case . and .. */
             continue;
         }
-        
+
         filepath_copy(&cur_sum_path, &parent->sum_path);
         filepath_os_append(&cur_sum_path, cur_dirent->d_name);
-        
+
         if (os_stat(cur_sum_path.os_path, &cur_stats) == -1) {
             fprintf(stderr, "Failed to stat %s\n", cur_sum_path.char_path);
             exit(EXIT_FAILURE);
         }
-        
+
         if ((cur_stats.st_mode & S_IFMT) == S_IFDIR) {
             /* Directory */
             if ((cur_dir = calloc(1, sizeof(romfs_dirent_ctx_t))) == NULL) {
                 fprintf(stderr, "Failed to allocate RomFS directory context!\n");
                 exit(EXIT_FAILURE);
             }
-            
+
             romfs_ctx->num_dirs++;
-            
+
             cur_dir->parent = parent;
             filepath_copy(&cur_dir->sum_path, &cur_sum_path);
             filepath_copy(&cur_dir->cur_path, &cur_path);
-            
+
             romfs_ctx->dir_table_size += 0x18 + align(strlen(cur_dir->cur_path.char_path)-1, 4);
-            
+
             /* Ordered insertion on sibling */
             if (child_dir_tree == NULL || strcmp(cur_dir->sum_path.char_path, child_dir_tree->sum_path.char_path) < 0) {
                 cur_dir->sibling = child_dir_tree;
@@ -188,13 +188,13 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
                         break;
                     }
                     prev = child;
-                    child = child->sibling;         
+                    child = child->sibling;
                 }
-                
+
                 prev->sibling = cur_dir;
                 cur_dir->sibling = child;
             }
-            
+
             /* Ordered insertion on next */
             romfs_dirent_ctx_t *tmp = parent->next, *tmp_prev = parent;
             while (tmp != NULL) {
@@ -202,11 +202,11 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
                     break;
                 }
                 tmp_prev = tmp;
-                tmp = tmp->next;         
+                tmp = tmp->next;
             }
             tmp_prev->next = cur_dir;
             cur_dir->next = tmp;
-            
+
             cur_dir = NULL;
         } else if ((cur_stats.st_mode & S_IFMT) == S_IFREG) {
             /* File */
@@ -214,16 +214,16 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
                 fprintf(stderr, "Failed to allocate RomFS File context!\n");
                 exit(EXIT_FAILURE);
             }
-            
+
             romfs_ctx->num_files++;
-            
+
             cur_file->parent = parent;
             filepath_copy(&cur_file->sum_path, &cur_sum_path);
             filepath_copy(&cur_file->cur_path, &cur_path);
             cur_file->size = cur_stats.st_size;
-            
+
             romfs_ctx->file_table_size += 0x20 + align(strlen(cur_file->cur_path.char_path)-1, 4);
-            
+
             /* Ordered insertion on sibling */
             if (child_file_tree == NULL || strcmp(cur_file->sum_path.char_path, child_file_tree->sum_path.char_path) < 0) {
                 cur_file->sibling = child_file_tree;
@@ -237,13 +237,13 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
                         break;
                     }
                     prev = child;
-                    child = child->sibling;         
+                    child = child->sibling;
                 }
-                
+
                 prev->sibling = cur_file;
                 cur_file->sibling = child;
             }
-            
+
             /* Ordered insertion on next */
             if (romfs_ctx->files == NULL || strcmp(cur_file->sum_path.char_path, romfs_ctx->files->sum_path.char_path) < 0) {
                 cur_file->next = romfs_ctx->files;
@@ -257,24 +257,24 @@ void romfs_visit_dir(romfs_dirent_ctx_t *parent, romfs_ctx_t *romfs_ctx) {
                         break;
                     }
                     prev = child;
-                    child = child->next;         
+                    child = child->next;
                 }
-                
+
                 prev->next = cur_file;
                 cur_file->next = child;
             }
-            
+
             cur_file = NULL;
         } else {
             fprintf(stderr, "Invalid FS object type for %s!\n", cur_path.char_path);
             exit(EXIT_FAILURE);
         }
     }
-	
+
     os_closedir(dir);
     parent->child = child_dir_tree;
     parent->file = child_file_tree;
-    
+
     cur_dir = child_dir_tree;
     while (cur_dir != NULL) {
         romfs_visit_dir(cur_dir, romfs_ctx);
@@ -288,18 +288,18 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
         fprintf(stderr, "Failed to allocate root context!\n");
         exit(EXIT_FAILURE);
     }
-    
+
     root_ctx->parent = root_ctx;
-    
+
     romfs_ctx_t romfs_ctx;
     memset(&romfs_ctx, 0, sizeof(romfs_ctx));
-    
+
     filepath_copy(&root_ctx->sum_path, in_dirpath);
     filepath_init(&root_ctx->cur_path);
     filepath_set(&root_ctx->cur_path, "");
     romfs_ctx.dir_table_size = 0x18; /* Root directory. */
     romfs_ctx.num_dirs = 1;
-    
+
     /* Visit all directories. */
     printf("Visiting directories...\n");
     romfs_visit_dir(root_ctx, &romfs_ctx);
@@ -307,46 +307,46 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
     uint32_t file_hash_table_entry_count = romfs_get_hash_table_count(romfs_ctx.num_files);
     romfs_ctx.dir_hash_table_size = 4 * dir_hash_table_entry_count;
     romfs_ctx.file_hash_table_size = 4 * file_hash_table_entry_count;
-    
+
     romfs_header_t header;
     memset(&header, 0, sizeof(header));
     romfs_fent_ctx_t *cur_file = NULL;
     romfs_dirent_ctx_t *cur_dir = NULL;
     uint32_t entry_offset = 0;
-    
-    
+
+
     uint32_t *dir_hash_table = malloc(romfs_ctx.dir_hash_table_size);
     if (dir_hash_table == NULL) {
         fprintf(stderr, "Failed to allocate directory hash table!\n");
         exit(EXIT_FAILURE);
     }
-    
+
     for (uint32_t i = 0; i < dir_hash_table_entry_count; i++) {
         dir_hash_table[i] = le_word(ROMFS_ENTRY_EMPTY);
     }
-    
+
     uint32_t *file_hash_table = malloc(romfs_ctx.file_hash_table_size);
     if (file_hash_table == NULL) {
         fprintf(stderr, "Failed to allocate file hash table!\n");
         exit(EXIT_FAILURE);
     }
-    
+
     for (uint32_t i = 0; i < file_hash_table_entry_count; i++) {
         file_hash_table[i] = le_word(ROMFS_ENTRY_EMPTY);
     }
-    
+
     romfs_direntry_t *dir_table = calloc(1, romfs_ctx.dir_table_size);
     if (dir_table == NULL) {
         fprintf(stderr, "Failed to allocate directory table!\n");
         exit(EXIT_FAILURE);
     }
-    
+
     romfs_fentry_t *file_table = calloc(1, romfs_ctx.file_table_size);
     if (file_table == NULL) {
         fprintf(stderr, "Failed to allocate file table!\n");
         exit(EXIT_FAILURE);
     }
-     
+
     printf("Calculating metadata...\n");
     /* Determine file offsets. */
     cur_file = romfs_ctx.files;
@@ -359,7 +359,7 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
         entry_offset += 0x20 + align(strlen(cur_file->cur_path.char_path)-1, 4);
         cur_file = cur_file->next;
     }
-    
+
     /* Determine dir offsets. */
     cur_dir = root_ctx;
     entry_offset = 0;
@@ -372,7 +372,7 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
         }
         cur_dir = cur_dir->next;
     }
-    
+
     /* Populate file tables. */
     cur_file = romfs_ctx.files;
     while (cur_file != NULL) {
@@ -381,47 +381,45 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
         cur_entry->sibling = le_word(cur_file->sibling == NULL ? ROMFS_ENTRY_EMPTY : cur_file->sibling->entry_offset);
         cur_entry->offset = le_dword(cur_file->offset);
         cur_entry->size = le_dword(cur_file->size);
-        
+
         uint32_t name_size = strlen(cur_file->cur_path.char_path)-1;
         uint32_t hash = calc_path_hash(cur_file->parent->entry_offset, (unsigned char *)cur_file->cur_path.char_path, 1, name_size);
         cur_entry->hash = file_hash_table[hash % file_hash_table_entry_count];
         file_hash_table[hash % file_hash_table_entry_count] = le_word(cur_file->entry_offset);
-        
+
         cur_entry->name_size = name_size;
         memcpy(cur_entry->name, cur_file->cur_path.char_path + 1, name_size);
-        
+
         cur_file = cur_file->next;
     }
-    
+
     /* Populate dir tables. */
     cur_dir = root_ctx;
     while (cur_dir != NULL) {
-        romfs_direntry_t *cur_entry = romfs_get_direntry(dir_table, cur_dir->entry_offset);   
+        romfs_direntry_t *cur_entry = romfs_get_direntry(dir_table, cur_dir->entry_offset);
         cur_entry->parent = le_word(cur_dir->parent->entry_offset);
         cur_entry->sibling = le_word(cur_dir->sibling == NULL ? ROMFS_ENTRY_EMPTY : cur_dir->sibling->entry_offset);
         cur_entry->child = le_word(cur_dir->child == NULL ? ROMFS_ENTRY_EMPTY : cur_dir->child->entry_offset);
         cur_entry->file = le_word(cur_dir->file == NULL ? ROMFS_ENTRY_EMPTY : cur_dir->file->entry_offset);
-        
+
         uint32_t name_size = (cur_dir == root_ctx) ? 0 : strlen(cur_dir->cur_path.char_path)-1;
         uint32_t hash = calc_path_hash((cur_dir == root_ctx) ? 0 : cur_dir->parent->entry_offset, (unsigned char *)cur_dir->cur_path.char_path, 1, name_size);
         cur_entry->hash = dir_hash_table[hash % dir_hash_table_entry_count];
         dir_hash_table[hash % dir_hash_table_entry_count] = le_word(cur_dir->entry_offset);
-        
+
         cur_entry->name_size = name_size;
         memcpy(cur_entry->name, cur_dir->cur_path.char_path + 1, name_size);
-        
-        romfs_dirent_ctx_t *temp = cur_dir;
+
         cur_dir = cur_dir->next;
-        free(temp);
     }
-    
+
     header.header_size = le_dword(sizeof(header));
     header.file_hash_table_size = le_dword(romfs_ctx.file_hash_table_size);
     header.file_table_size = le_dword(romfs_ctx.file_table_size);
     header.dir_hash_table_size = le_dword(romfs_ctx.dir_hash_table_size);
     header.dir_table_size = le_dword(romfs_ctx.dir_table_size);
     header.file_partition_ofs = le_dword(ROMFS_FILEPARTITION_OFS);
-    
+
     /* Abuse of endianness follows. */
     uint64_t dir_hash_table_ofs = align64(romfs_ctx.file_partition_size + ROMFS_FILEPARTITION_OFS, 4);
     header.dir_hash_table_ofs = dir_hash_table_ofs;
@@ -432,10 +430,10 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
     header.dir_table_ofs = le_dword(header.dir_table_ofs);
     header.file_hash_table_ofs = le_dword(header.file_hash_table_ofs);
     header.file_table_ofs = le_dword(header.file_table_ofs);
-    
+
     fseeko64(f_out, base_offset, SEEK_SET);
     fwrite(&header, 1, sizeof(header), f_out);
-    
+
     /* Write files. */
     unsigned char *buffer = malloc(0x400000);
     if (buffer == NULL) {
@@ -449,7 +447,7 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
             fprintf(stderr, "Failed to open %s!\n", cur_file->sum_path.char_path);
             exit(EXIT_FAILURE);
         }
-        
+
         printf("Writing %s to RomFS image...\n", cur_file->sum_path.char_path);
         fseeko64(f_out, base_offset + cur_file->offset + ROMFS_FILEPARTITION_OFS, SEEK_SET);
         uint64_t offset = 0;
@@ -458,66 +456,82 @@ size_t build_romfs_into_file(filepath_t *in_dirpath, FILE *f_out, off_t base_off
             if (cur_file->size - offset < read_size) {
                 read_size = cur_file->size - offset;
             }
-            
+
             if (fread(buffer, 1, read_size, f_in) != read_size) {
                 fprintf(stderr, "Failed to read from %s!\n", cur_file->sum_path.char_path);
                 exit(EXIT_FAILURE);
             }
-            
+
             if (fwrite(buffer, 1, read_size, f_out) != read_size) {
                 fprintf(stderr, "Failed to write to output!\n");
                 exit(EXIT_FAILURE);
             }
-            
+
             offset += read_size;
         }
-        
+
         os_fclose(f_in);
-        
+
+        cur_file = cur_file->next;
+    }
+    free(buffer);
+
+    /* Free all files. */
+    cur_file = romfs_ctx.files;
+    while (cur_file != NULL) {
         romfs_fent_ctx_t *temp = cur_file;
         cur_file = cur_file->next;
         free(temp);
     }
-    free(buffer);
-    
+    romfs_ctx.files = NULL;
+
+    /* Free all directories. */
+    cur_dir = root_ctx;
+    while (cur_dir != NULL) {
+        romfs_dirent_ctx_t *temp = cur_dir;
+        cur_dir = cur_dir->next;
+        free(temp);
+    }
+    root_ctx = NULL;
+
     fseeko64(f_out, base_offset + dir_hash_table_ofs, SEEK_SET);
     if (fwrite(dir_hash_table, 1, romfs_ctx.dir_hash_table_size, f_out) != romfs_ctx.dir_hash_table_size) {
         fprintf(stderr, "Failed to write dir hash table!\n");
         exit(EXIT_FAILURE);
     }
     free(dir_hash_table);
-    
+
     if (fwrite(dir_table, 1, romfs_ctx.dir_table_size, f_out) != romfs_ctx.dir_table_size) {
         fprintf(stderr, "Failed to write dir table!\n");
         exit(EXIT_FAILURE);
     }
     free(dir_table);
-    
+
     if (fwrite(file_hash_table, 1, romfs_ctx.file_hash_table_size, f_out) != romfs_ctx.file_hash_table_size) {
         fprintf(stderr, "Failed to write file hash table!\n");
         exit(EXIT_FAILURE);
     }
     free(file_hash_table);
-    
+
     if (fwrite(file_table, 1, romfs_ctx.file_table_size, f_out) != romfs_ctx.file_table_size) {
         fprintf(stderr, "Failed to write file table!\n");
         exit(EXIT_FAILURE);
     }
     free(file_table);
-    
+
     return dir_hash_table_ofs + romfs_ctx.dir_hash_table_size + romfs_ctx.dir_table_size + romfs_ctx.file_hash_table_size + romfs_ctx.file_table_size;
 }
 
 size_t build_romfs(filepath_t *in_dirpath, filepath_t *out_romfspath) {
     FILE *f_out = NULL;
-    
+
     if ((f_out = os_fopen(out_romfspath->os_path, OS_MODE_WRITE)) == NULL) {
         fprintf(stderr, "Failed to open %s!\n", out_romfspath->char_path);
         exit(EXIT_FAILURE);
     }
-    
+
     size_t sz = build_romfs_into_file(in_dirpath, f_out, 0);
-    
+
     fclose(f_out);
     return sz;
 }
@@ -525,21 +539,21 @@ size_t build_romfs(filepath_t *in_dirpath, filepath_t *out_romfspath) {
 size_t build_romfs_by_paths(char *dir, char *out_fn) {
     filepath_t dirpath;
     filepath_t outpath;
-    
+
     filepath_init(&dirpath);
     filepath_init(&outpath);
-    
+
     filepath_set(&dirpath, dir);
     filepath_set(&outpath, out_fn);
-    
+
     return build_romfs(&dirpath, &outpath);
 }
 
 size_t build_romfs_by_path_into_file(char *dir, FILE *f_out, off_t offset) {
     filepath_t dirpath;
-    
+
     filepath_init(&dirpath);
-    
+
     filepath_set(&dirpath, dir);
 
     return build_romfs_into_file(&dirpath, f_out, offset);