mirrors/nxdumptool
1
0
Fork 0
mirror of https://github.com/DarkMatterCore/nxdumptool.git synced 2024-11-27 04:32:18 +00:00
Code Issues Releases Activity
nxdumptool/source/core/romfs.c
Pablo Curiel 364b3f39dc romfs: use hash buckets for FS entry lookups. 
* romfs: add hash bucket fields to RomFileSystemContext struct.
* romfs: remove current offset fields from RomFileSystemContext struct and all functions that relied on them.
* romfs: add romfsCalculateEntryHash().
* romfs: update romfsInitializeContext() to also load file/directory hash buckets.
* romfs: update romfsGetTotalDataSize() to make up for the removed functions.
* romfs: update romfsGetChild*EntryByName() functions to use hash bucket lookups.

Other changes include:

* devoptab: add missing exit macros to some FS operations across all interfaces.

* poc: update extractedRomFsReadThreadFunc() to make up for the removed RomFS functions.
2023-12-22 12:20:27 +01:00

807 lines
30 KiB
C
Raw Blame History

/*
* romfs.c
*
* Copyright (c) 2020-2023, DarkMatterCore <pabloacurielz@gmail.com>.
*
* This file is part of nxdumptool (https://github.com/DarkMatterCore/nxdumptool).
*
* nxdumptool is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* nxdumptool is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "nxdt_utils.h"
#include "romfs.h"
/* Helper macros. */
#define ROMFS_ENTRY_OFFSET(entry, table) (u32)((uintptr_t)entry - (uintptr_t)table)
/* Function prototypes. */
static RomFileSystemDirectoryEntry *romfsGetChildDirectoryEntryByName(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, const char *name);
static RomFileSystemFileEntry *romfsGetChildFileEntryByName(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, const char *name);
static u32 romfsCalculateEntryHash(RomFileSystemContext *ctx, u32 parent_offset, const char *name, size_t name_len, bool is_file);
bool romfsInitializeContext(RomFileSystemContext *out, NcaFsSectionContext *base_nca_fs_ctx, NcaFsSectionContext *patch_nca_fs_ctx)
{
u64 dir_bucket_offset = 0, dir_table_offset = 0;
u64 file_bucket_offset = 0, file_table_offset = 0;
NcaContext *base_nca_ctx = NULL, *patch_nca_ctx = NULL;
bool dump_fs_header = false, success = false;
/* Check if the base RomFS is missing (e.g. Fortnite, World of Tanks Blitz, etc.). */
bool missing_base_romfs = (!base_nca_fs_ctx || !base_nca_fs_ctx->enabled || (base_nca_fs_ctx->section_type != NcaFsSectionType_RomFs && \
base_nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs));
if (!out || (!patch_nca_fs_ctx && (missing_base_romfs || base_nca_fs_ctx->has_sparse_layer)) || \
(!missing_base_romfs && (!(base_nca_ctx = base_nca_fs_ctx->nca_ctx) || (base_nca_ctx->format_version == NcaVersion_Nca0 && \
(base_nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs || base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalSha256)) || \
(base_nca_ctx->format_version != NcaVersion_Nca0 && (base_nca_fs_ctx->section_type != NcaFsSectionType_RomFs || \
(base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalIntegrity && base_nca_fs_ctx->hash_type != NcaHashType_HierarchicalIntegritySha3))) || \
(base_nca_ctx->rights_id_available && !base_nca_ctx->titlekey_retrieved))) || (patch_nca_fs_ctx && (!patch_nca_fs_ctx->enabled || \
!(patch_nca_ctx = patch_nca_fs_ctx->nca_ctx) || (!missing_base_romfs && patch_nca_ctx->format_version != base_nca_ctx->format_version) || \
patch_nca_fs_ctx->section_type != NcaFsSectionType_PatchRomFs || (patch_nca_ctx->rights_id_available && !patch_nca_ctx->titlekey_retrieved))))
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Free output context beforehand. */
romfsFreeContext(out);
NcaStorageContext *base_storage_ctx = &(out->storage_ctx[0]), *patch_storage_ctx = &(out->storage_ctx[1]);
bool is_nca0_romfs = (base_nca_fs_ctx && base_nca_fs_ctx->section_type == NcaFsSectionType_Nca0RomFs);
/* Initialize base NCA storage context. */
if (!missing_base_romfs && !ncaStorageInitializeContext(base_storage_ctx, base_nca_fs_ctx, NULL))
{
LOG_MSG_ERROR("Failed to initialize base NCA storage context!");
goto end;
}
if (patch_nca_fs_ctx)
{
/* Initialize base NCA storage context. */
if (!ncaStorageInitializeContext(patch_storage_ctx, patch_nca_fs_ctx, missing_base_romfs ? NULL : base_storage_ctx))
{
LOG_MSG_ERROR("Failed to initialize patch NCA storage context!");
goto end;
}
/* Set default NCA FS storage context. */
out->is_patch = true;
out->default_storage_ctx = patch_storage_ctx;
} else {
/* Set default NCA FS storage context. */
out->is_patch = false;
out->default_storage_ctx = base_storage_ctx;
}
/* Get RomFS offset and size. */
if (!ncaStorageGetHashTargetExtents(out->default_storage_ctx, &(out->offset), &(out->size)))
{
LOG_MSG_ERROR("Failed to get target hash layer extents!");
goto end;
}
/* Read RomFS header. */
if (!ncaStorageRead(out->default_storage_ctx, &(out->header), sizeof(RomFileSystemHeader), out->offset))
{
LOG_MSG_ERROR("Failed to read RomFS header!");
goto end;
}
if ((is_nca0_romfs && out->header.old_format.header_size != ROMFS_OLD_HEADER_SIZE) || (!is_nca0_romfs && out->header.cur_format.header_size != ROMFS_HEADER_SIZE))
{
LOG_MSG_ERROR("Invalid RomFS header size!");
dump_fs_header = true;
goto end;
}
/* Read directory bucket. */
dir_bucket_offset = (is_nca0_romfs ? (u64)out->header.old_format.directory_bucket_offset : out->header.cur_format.directory_bucket_offset);
out->dir_bucket_size = (is_nca0_romfs ? (u64)out->header.old_format.directory_bucket_size : out->header.cur_format.directory_bucket_size);
if (!out->dir_bucket_size || (dir_bucket_offset + out->dir_bucket_size) > out->size)
{
LOG_MSG_ERROR("Invalid RomFS directory bucket!");
dump_fs_header = true;
goto end;
}
out->dir_bucket = malloc(out->dir_bucket_size);
if (!out->dir_bucket)
{
LOG_MSG_ERROR("Unable to allocate memory for RomFS directory bucket!");
goto end;
}
if (!ncaStorageRead(out->default_storage_ctx, out->dir_bucket, out->dir_bucket_size, out->offset + dir_bucket_offset))
{
LOG_MSG_ERROR("Failed to read RomFS directory bucket!");
goto end;
}
/* Read directory entries table. */
dir_table_offset = (is_nca0_romfs ? (u64)out->header.old_format.directory_entry_offset : out->header.cur_format.directory_entry_offset);
out->dir_table_size = (is_nca0_romfs ? (u64)out->header.old_format.directory_entry_size : out->header.cur_format.directory_entry_size);
if (!out->dir_table_size || (dir_table_offset + out->dir_table_size) > out->size)
{
LOG_MSG_ERROR("Invalid RomFS directory entries table!");
dump_fs_header = true;
goto end;
}
out->dir_table = malloc(out->dir_table_size);
if (!out->dir_table)
{
LOG_MSG_ERROR("Unable to allocate memory for RomFS directory entries table!");
goto end;
}
if (!ncaStorageRead(out->default_storage_ctx, out->dir_table, out->dir_table_size, out->offset + dir_table_offset))
{
LOG_MSG_ERROR("Failed to read RomFS directory entries table!");
goto end;
}
/* Read file bucket. */
file_bucket_offset = (is_nca0_romfs ? (u64)out->header.old_format.file_bucket_offset : out->header.cur_format.file_bucket_offset);
out->file_bucket_size = (is_nca0_romfs ? (u64)out->header.old_format.file_bucket_size : out->header.cur_format.file_bucket_size);
if (!out->file_bucket_size || (file_bucket_offset + out->file_bucket_size) > out->size)
{
LOG_MSG_ERROR("Invalid RomFS file bucket!");
dump_fs_header = true;
goto end;
}
out->file_bucket = malloc(out->file_bucket_size);
if (!out->file_bucket)
{
LOG_MSG_ERROR("Unable to allocate memory for RomFS file bucket!");
goto end;
}
if (!ncaStorageRead(out->default_storage_ctx, out->file_bucket, out->file_bucket_size, out->offset + file_bucket_offset))
{
LOG_MSG_ERROR("Failed to read RomFS file bucket!");
goto end;
}
/* Read file entries table. */
file_table_offset = (is_nca0_romfs ? (u64)out->header.old_format.file_entry_offset : out->header.cur_format.file_entry_offset);
out->file_table_size = (is_nca0_romfs ? (u64)out->header.old_format.file_entry_size : out->header.cur_format.file_entry_size);
if (!out->file_table_size || (file_table_offset + out->file_table_size) > out->size)
{
LOG_MSG_ERROR("Invalid RomFS file entries table!");
dump_fs_header = true;
goto end;
}
out->file_table = malloc(out->file_table_size);
if (!out->file_table)
{
LOG_MSG_ERROR("Unable to allocate memory for RomFS file entries table!");
goto end;
}
if (!ncaStorageRead(out->default_storage_ctx, out->file_table, out->file_table_size, out->offset + file_table_offset))
{
LOG_MSG_ERROR("Failed to read RomFS file entries table!");
goto end;
}
/* Get file data body offset. */
out->body_offset = (is_nca0_romfs ? (u64)out->header.old_format.body_offset : out->header.cur_format.body_offset);
if (out->body_offset >= out->size)
{
LOG_MSG_ERROR("Invalid RomFS file data body!");
dump_fs_header = true;
goto end;
}
/* Update flag. */
success = true;
end:
if (!success)
{
if (dump_fs_header) LOG_DATA_DEBUG(&(out->header), sizeof(RomFileSystemHeader), "RomFS header dump:");
romfsFreeContext(out);
}
return success;
}
bool romfsReadFileSystemData(RomFileSystemContext *ctx, void *out, u64 read_size, u64 offset)
{
if (!romfsIsValidContext(ctx) || !out || !read_size || (offset + read_size) > ctx->size)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Read filesystem data. */
if (!ncaStorageRead(ctx->default_storage_ctx, out, read_size, ctx->offset + offset))
{
LOG_MSG_ERROR("Failed to read RomFS data!");
return false;
}
return true;
}
bool romfsReadFileEntryData(RomFileSystemContext *ctx, RomFileSystemFileEntry *file_entry, void *out, u64 read_size, u64 offset)
{
if (!romfsIsValidContext(ctx) || !file_entry || !file_entry->size || (file_entry->offset + file_entry->size) > ctx->size || !out || !read_size || \
(offset + read_size) > file_entry->size)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Read entry data. */
if (!romfsReadFileSystemData(ctx, out, read_size, ctx->body_offset + file_entry->offset + offset))
{
LOG_MSG_ERROR("Failed to read RomFS file entry data!");
return false;
}
return true;
}
bool romfsGetTotalDataSize(RomFileSystemContext *ctx, bool only_updated, u64 *out_size)
{
if (!romfsIsValidContext(ctx) || !out_size || (only_updated && (!ctx->is_patch || ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_PatchRomFs)))
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
RomFileSystemFileEntry *file_entry = NULL;
u64 total_size = 0, cur_entry_offset = 0;
bool success = false;
/* Loop through all file entries. */
while(cur_entry_offset < ctx->file_table_size)
{
bool updated = false;
/* Get current file entry. */
if (!(file_entry = romfsGetFileEntryByOffset(ctx, cur_entry_offset)))
{
LOG_MSG_ERROR("Failed to retrieve current file entry! (0x%lX, 0x%lX).", cur_entry_offset, ctx->file_table_size);
goto end;
}
/* Update total data size, taking into account the only_updated flag. */
if (only_updated && !romfsIsFileEntryUpdated(ctx, file_entry, &updated))
{
LOG_MSG_ERROR("Failed to determine if file entry is updated or not! (0x%lX, 0x%lX).", cur_entry_offset, ctx->file_table_size);
goto end;
}
if (!only_updated || (only_updated && updated)) total_size += file_entry->size;
/* Get the offset for the next file entry. */
cur_entry_offset += ALIGN_UP(sizeof(RomFileSystemFileEntry) + file_entry->name_length, ROMFS_TABLE_ENTRY_ALIGNMENT);
}
/* Update output values. */
*out_size = total_size;
success = true;
end:
return success;
}
bool romfsGetDirectoryDataSize(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, u64 *out_size)
{
if (!romfsIsValidContext(ctx) || !dir_entry || !out_size)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Short-circuit: check if we're dealing with an empty directory. */
if (dir_entry->file_offset == ROMFS_VOID_ENTRY && dir_entry->directory_offset == ROMFS_VOID_ENTRY)
{
*out_size = 0;
return true;
}
RomFileSystemFileEntry *cur_file_entry = NULL;
RomFileSystemDirectoryEntry *cur_dir_entry = NULL;
u64 total_size = 0, cur_entry_offset = 0, child_dir_size = 0;
bool success = false;
/* Loop through the child file entries' linked list. */
cur_entry_offset = dir_entry->file_offset;
while(cur_entry_offset != ROMFS_VOID_ENTRY)
{
/* Get current file entry. */
if (!(cur_file_entry = romfsGetFileEntryByOffset(ctx, cur_entry_offset)))
{
LOG_MSG_ERROR("Failed to retrieve file entry! (0x%lX, 0x%lX).", cur_entry_offset, ctx->file_table_size);
goto end;
}
/* Update total data size. */
total_size += cur_file_entry->size;
/* Update current file entry offset. */
cur_entry_offset = cur_file_entry->next_offset;
}
/* Loop through the child directory entries' linked list. */
cur_entry_offset = dir_entry->directory_offset;
while(cur_entry_offset != ROMFS_VOID_ENTRY)
{
/* Get current directory entry. */
if (!(cur_dir_entry = romfsGetDirectoryEntryByOffset(ctx, cur_entry_offset)))
{
LOG_MSG_ERROR("Failed to retrieve directory entry! (0x%lX, 0x%lX).", cur_entry_offset, ctx->dir_table_size);
goto end;
}
/* Calculate directory size. */
if (!romfsGetDirectoryDataSize(ctx, cur_dir_entry, &child_dir_size))
{
LOG_MSG_ERROR("Failed to get size for directory entry! (0x%lX, 0x%lX).", cur_entry_offset, ctx->dir_table_size);
goto end;
}
/* Update total data size. */
total_size += child_dir_size;
/* Update current directory entry offset. */
cur_entry_offset = cur_dir_entry->next_offset;
}
/* Update output values. */
*out_size = total_size;
success = true;
end:
return success;
}
RomFileSystemDirectoryEntry *romfsGetDirectoryEntryByPath(RomFileSystemContext *ctx, const char *path)
{
size_t path_len = 0;
char *path_dup = NULL, *pch = NULL, *state = NULL;
RomFileSystemDirectoryEntry *dir_entry = NULL;
if (!romfsIsValidContext(ctx) || !path || *path != '/' || !(dir_entry = romfsGetDirectoryEntryByOffset(ctx, 0)))
{
LOG_MSG_ERROR("Invalid parameters!");
return NULL;
}
/* Retrieve path length. */
path_len = strlen(path);
/* Short-circuit: check if the root directory was requested. */
if (path_len == 1) return dir_entry;
/* Duplicate path to avoid problems with strtok_r(). */
if (!(path_dup = strdup(path)))
{
LOG_MSG_ERROR("Unable to duplicate input path! (\"%s\").", path);
dir_entry = NULL;
goto end;
}
/* Tokenize duplicated path using path separators. */
pch = strtok_r(path_dup, "/", &state);
if (!pch)
{
LOG_MSG_ERROR("Failed to tokenize input path! (\"%s\").", path);
dir_entry = NULL;
goto end;
}
/* Loop through all path elements. */
while(pch)
{
/* Get child directory entry using the current token. */
if (!(dir_entry = romfsGetChildDirectoryEntryByName(ctx, dir_entry, pch)))
{
LOG_MSG_ERROR("Failed to retrieve directory entry by name for \"%s\"! (\"%s\").", pch, path);
break;
}
/* Move onto the next token. */
pch = strtok_r(NULL, "/", &state);
}
end:
if (path_dup) free(path_dup);
return dir_entry;
}
RomFileSystemFileEntry *romfsGetFileEntryByPath(RomFileSystemContext *ctx, const char *path)
{
size_t path_len = 0;
char *path_dup = NULL, *filename = NULL;
RomFileSystemFileEntry *file_entry = NULL;
RomFileSystemDirectoryEntry *dir_entry = NULL;
if (!romfsIsValidContext(ctx) || !path || *path != '/')
{
LOG_MSG_ERROR("Invalid parameters!");
return NULL;
}
/* Retrieve path length. */
path_len = strlen(path);
/* Duplicate path. */
if (!(path_dup = strdup(path)))
{
LOG_MSG_ERROR("Unable to duplicate input path! (\"%s\").", path);
goto end;
}
/* Remove any trailing slashes. */
while(path_dup[path_len - 1] == '/')
{
path_dup[path_len - 1] = '\0';
path_len--;
}
/* Safety check. */
if (!path_len || !(filename = strrchr(path_dup, '/')))
{
LOG_MSG_ERROR("Invalid input path! (\"%s\").", path);
goto end;
}
/* Remove leading slash and adjust filename string pointer. */
*filename++ = '\0';
/* Retrieve directory entry. */
/* If the first character is NULL, then just retrieve the root directory entry. */
if (!(dir_entry = (*path_dup ? romfsGetDirectoryEntryByPath(ctx, path_dup) : romfsGetDirectoryEntryByOffset(ctx, 0))))
{
LOG_MSG_ERROR("Failed to retrieve directory entry for \"%s\"! (\"%s\").", *path_dup ? path_dup : "/", path);
goto end;
}
/* Retrieve file entry. */
if (!(file_entry = romfsGetChildFileEntryByName(ctx, dir_entry, filename))) LOG_MSG_ERROR("Failed to retrieve file entry by name for \"%s\"! (\"%s\").", filename, path);
end:
if (path_dup) free(path_dup);
return file_entry;
}
bool romfsGeneratePathFromDirectoryEntry(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, char *out_path, size_t out_path_size, u8 illegal_char_replace_type)
{
size_t path_len = 0;
u64 dir_offset = ROMFS_VOID_ENTRY;
u32 dir_entries_count = 0;
RomFileSystemDirectoryEntry **dir_entries = NULL, **tmp_dir_entries = NULL;
bool success = false;
if (!romfsIsValidContext(ctx) || !dir_entry || (!dir_entry->name_length && dir_entry->parent_offset) || !out_path || out_path_size < 2 || \
illegal_char_replace_type > RomFileSystemPathIllegalCharReplaceType_KeepAsciiCharsOnly)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Short-circuit: check if we're dealing with the root directory entry. */
if (!dir_entry->name_length)
{
sprintf(out_path, "/");
return true;
}
/* Allocate memory for our directory entries pointer array. */
dir_entries = calloc(1, sizeof(RomFileSystemDirectoryEntry*));
if (!dir_entries)
{
LOG_MSG_ERROR("Unable to allocate memory for directory entries!");
goto end;
}
/* Update stats. */
path_len = (1 + dir_entry->name_length);
*dir_entries = dir_entry;
dir_entries_count++;
while(true)
{
/* Get parent directory offset. Break out of the loop if we reached the root directory. */
dir_offset = dir_entries[dir_entries_count - 1]->parent_offset;
if (!dir_offset) break;
/* Reallocate directory entries pointer array. */
if (!(tmp_dir_entries = realloc(dir_entries, (dir_entries_count + 1) * sizeof(RomFileSystemDirectoryEntry*))))
{
LOG_MSG_ERROR("Unable to reallocate directory entries buffer!");
goto end;
}
dir_entries = tmp_dir_entries;
tmp_dir_entries = NULL;
/* Retrieve parent directory entry using the offset we got earlier. */
RomFileSystemDirectoryEntry **cur_dir_entry = &(dir_entries[dir_entries_count]);
if (!(*cur_dir_entry = romfsGetDirectoryEntryByOffset(ctx, dir_offset)) || !(*cur_dir_entry)->name_length)
{
LOG_MSG_ERROR("Failed to retrieve directory entry!");
goto end;
}
/* Update stats. */
path_len += (1 + (*cur_dir_entry)->name_length);
dir_entries_count++;
}
/* Make sure the output buffer is big enough to hold the full path + NULL terminator. */
if (path_len >= out_path_size)
{
LOG_MSG_ERROR("Output path length exceeds output buffer size! (%lu >= %lu).", path_len, out_path_size);
goto end;
}
/* Generate output path, looping through our directory entries pointer array in reverse order. */
*out_path = '\0';
path_len = 0;
for(u32 i = dir_entries_count; i > 0; i--)
{
/* Get current directory entry. */
RomFileSystemDirectoryEntry *cur_dir_entry = dir_entries[i - 1];
/* Concatenate path separator and current directory name to the output buffer. */
strcat(out_path, "/");
strncat(out_path, cur_dir_entry->name, cur_dir_entry->name_length);
path_len++;
if (illegal_char_replace_type)
{
/* Replace illegal characters within this directory name, then update the full path length. */
utilsReplaceIllegalCharacters(out_path + path_len, illegal_char_replace_type == RomFileSystemPathIllegalCharReplaceType_KeepAsciiCharsOnly);
path_len += strlen(out_path + path_len);
} else {
/* Update full path length. */
path_len += cur_dir_entry->name_length;
}
}
/* Update return value. */
success = true;
end:
if (dir_entries) free(dir_entries);
return success;
}
bool romfsGeneratePathFromFileEntry(RomFileSystemContext *ctx, RomFileSystemFileEntry *file_entry, char *out_path, size_t out_path_size, u8 illegal_char_replace_type)
{
size_t path_len = 0;
RomFileSystemDirectoryEntry *dir_entry = NULL;
bool success = false;
if (!romfsIsValidContext(ctx) || !file_entry || !file_entry->name_length || !out_path || out_path_size < 2 || \
!(dir_entry = romfsGetDirectoryEntryByOffset(ctx, file_entry->parent_offset)) || illegal_char_replace_type > RomFileSystemPathIllegalCharReplaceType_KeepAsciiCharsOnly)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
/* Retrieve full RomFS path up to the file entry name. */
if (!romfsGeneratePathFromDirectoryEntry(ctx, dir_entry, out_path, out_path_size, illegal_char_replace_type))
{
LOG_MSG_ERROR("Failed to retrieve RomFS directory path!");
goto end;
}
/* Make sure the output buffer is big enough to hold the full path + NULL terminator. */
path_len = strlen(out_path);
if ((path_len + 1 + file_entry->name_length) >= out_path_size)
{
LOG_MSG_ERROR("Output path length exceeds output buffer size! (%lu >= %lu).", path_len + 1 + file_entry->name_length, out_path_size);
goto end;
}
/* Concatenate path separator if our parent directory isn't the root directory. */
if (file_entry->parent_offset)
{
strcat(out_path, "/");
path_len++;
}
/* Concatenate file entry name. */
strncat(out_path, file_entry->name, file_entry->name_length);
/* Replace illegal characters within the file name, if needed. */
if (illegal_char_replace_type) utilsReplaceIllegalCharacters(out_path + path_len, illegal_char_replace_type == RomFileSystemPathIllegalCharReplaceType_KeepAsciiCharsOnly);
/* Update return value. */
success = true;
end:
return success;
}
bool romfsIsFileEntryUpdated(RomFileSystemContext *ctx, RomFileSystemFileEntry *file_entry, bool *out)
{
if (!romfsIsValidContext(ctx) || !ctx->is_patch || ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_PatchRomFs || \
!file_entry || !file_entry->size || (file_entry->offset + file_entry->size) > ctx->size || !out)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
u64 file_offset = (ctx->offset + ctx->body_offset + file_entry->offset);
bool success = false;
/* Short-circuit: check if we're dealing with a Patch RomFS with a missing base RomFS. */
if (!ncaStorageIsValidContext(&(ctx->storage_ctx[0])))
{
*out = success = true;
goto end;
}
/* Check if any sections from this block belong to the Patch storage. */
if (!ncaStorageIsBlockWithinPatchStorageRange(ctx->default_storage_ctx, file_offset, file_entry->size, out))
{
LOG_MSG_ERROR("Failed to determine if file entry is within Patch storage range!");
goto end;
}
/* Update return value. */
success = true;
end:
return success;
}
bool romfsGenerateFileEntryPatch(RomFileSystemContext *ctx, RomFileSystemFileEntry *file_entry, const void *data, u64 data_size, u64 data_offset, RomFileSystemFileEntryPatch *out)
{
if (!romfsIsValidContext(ctx) || ctx->is_patch || ctx->default_storage_ctx->base_storage_type != NcaStorageBaseStorageType_Regular || \
(ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_Nca0RomFs && ctx->default_storage_ctx->nca_fs_ctx->section_type != NcaFsSectionType_RomFs) || \
!file_entry || !file_entry->size || (file_entry->offset + file_entry->size) > ctx->size || !data || !data_size || (data_offset + data_size) > file_entry->size || !out)
{
LOG_MSG_ERROR("Invalid parameters!");
return false;
}
NcaFsSectionContext *nca_fs_ctx = ctx->default_storage_ctx->nca_fs_ctx;
u64 fs_offset = (ctx->body_offset + file_entry->offset + data_offset);
bool success = false;
if (nca_fs_ctx->section_type == NcaFsSectionType_Nca0RomFs)
{
out->use_old_format_patch = true;
success = ncaGenerateHierarchicalSha256Patch(nca_fs_ctx, data, data_size, fs_offset, &(out->old_format_patch));
} else {
out->use_old_format_patch = false;
success = ncaGenerateHierarchicalIntegrityPatch(nca_fs_ctx, data, data_size, fs_offset, &(out->cur_format_patch));
}
out->written = false;
if (!success) LOG_MSG_ERROR("Failed to generate 0x%lX bytes Hierarchical%s patch at offset 0x%lX for RomFS file entry!", data_size, \
nca_fs_ctx->section_type == NcaFsSectionType_Nca0RomFs ? "Sha256" : "Integrity", fs_offset);
return success;
}
static RomFileSystemDirectoryEntry *romfsGetChildDirectoryEntryByName(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, const char *name)
{
size_t name_len = 0;
RomFileSystemDirectoryEntry *child_dir_entry = NULL;
u32 hash = 0, parent_offset = 0, dir_offset = 0;
if (!dir_entry || !name || !(name_len = strlen(name)))
{
LOG_MSG_ERROR("Invalid parameters!");
return NULL;
}
/* Calculate hash for the child directory entry. */
parent_offset = ROMFS_ENTRY_OFFSET(dir_entry, ctx->dir_table);
hash = romfsCalculateEntryHash(ctx, parent_offset, name, name_len, false);
//LOG_MSG_DEBUG("parent_offset: 0x%X, parent_name: \"%.*s\", name: \"%s\", hash: 0x%X", parent_offset, (int)dir_entry->name_length, dir_entry->name, name, hash);
/* Perform lookup using the directory bucket. */
dir_offset = ctx->dir_bucket[hash];
while(dir_offset != ROMFS_VOID_ENTRY)
{
/* Get current directory entry. */
if (!(child_dir_entry = romfsGetDirectoryEntryByOffset(ctx, dir_offset)))
{
LOG_MSG_ERROR("Failed to retrieve directory entry! (0x%X, 0x%lX).", dir_offset, ctx->dir_table_size);
break;
}
//LOG_MSG_DEBUG("offset: 0x%X, parent: 0x%X, name: \"%.*s\"", dir_offset, child_dir_entry->parent_offset, (int)child_dir_entry->name_length, child_dir_entry->name);
/* Check if we found the right child directory entry. */
/* strncmp() is used here instead of strcmp() because names stored in RomFS sections are not always NULL terminated. */
/* If the name ends at a 4-byte boundary, the next entry starts immediately. */
if (child_dir_entry->parent_offset == parent_offset && child_dir_entry->name_length == name_len && !strncmp(child_dir_entry->name, name, name_len)) return child_dir_entry;
/* Update current directory entry offset. */
dir_offset = child_dir_entry->bucket_offset;
}
return NULL;
}
static RomFileSystemFileEntry *romfsGetChildFileEntryByName(RomFileSystemContext *ctx, RomFileSystemDirectoryEntry *dir_entry, const char *name)
{
size_t name_len = 0;
RomFileSystemFileEntry *child_file_entry = NULL;
u32 hash = 0, parent_offset = 0, file_offset = 0;
if (!dir_entry || !name || !(name_len = strlen(name)))
{
LOG_MSG_ERROR("Invalid parameters!");
return NULL;
}
/* Calculate hash for the child file entry. */
parent_offset = ROMFS_ENTRY_OFFSET(dir_entry, ctx->dir_table);
hash = romfsCalculateEntryHash(ctx, parent_offset, name, name_len, true);
//LOG_MSG_DEBUG("parent_offset: 0x%X, parent_name: \"%.*s\", name: \"%s\", hash: 0x%X", parent_offset, (int)dir_entry->name_length, dir_entry->name, name, hash);
/* Perform lookup using the file bucket. */
file_offset = ctx->file_bucket[hash];
while(file_offset != ROMFS_VOID_ENTRY)
{
/* Get current file entry. */
if (!(child_file_entry = romfsGetFileEntryByOffset(ctx, file_offset)))
{
LOG_MSG_ERROR("Failed to retrieve file entry! (0x%X, 0x%lX).", file_offset, ctx->file_table_size);
break;
}
//LOG_MSG_DEBUG("offset: 0x%X, parent: 0x%X, name: \"%.*s\"", file_offset, child_file_entry->parent_offset, (int)child_file_entry->name_length, child_file_entry->name);
/* Check if we found the right child file entry. */
/* strncmp() is used here instead of strcmp() because names stored in RomFS sections are not always NULL terminated. */
/* If the name ends at a 4-byte boundary, the next entry starts immediately. */
if (child_file_entry->parent_offset == parent_offset && child_file_entry->name_length == name_len && !strncmp(child_file_entry->name, name, name_len)) return child_file_entry;
/* Update current file entry offset. */
file_offset = child_file_entry->bucket_offset;
}
return NULL;
}
static u32 romfsCalculateEntryHash(RomFileSystemContext *ctx, u32 parent_offset, const char *name, size_t name_len, bool is_file)
{
u32 hash = (parent_offset ^ 123456789);
u32 total = ((u32)(is_file ? ctx->file_bucket_size : ctx->dir_bucket_size) / sizeof(u32));
for(size_t i = 0; i < name_len; i++) hash = (((hash >> 5) | (hash << 27)) ^ name[i]);
return (hash % total);
}
Reference in a new issue View git blame Copy permalink