mirror of
https://github.com/wiidev/usbloadergx.git
synced 2024-09-08 08:33:19 +02:00
530 lines
11 KiB
C
530 lines
11 KiB
C
/****************************************************************************
|
|
* USB Loader GX Team
|
|
* openingbnr
|
|
*
|
|
* Extract opening.bnr/banner.bin/sound.bin/icon.bin
|
|
*
|
|
* Copyright 2008 Magicus <magicus@gmail.com>
|
|
* Licensed under the terms of the GNU GPL, version 2
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
|
|
* Version 1.0 Initial release
|
|
***************************************************************************/
|
|
|
|
#define _GNU_SOURCE
|
|
|
|
#include <ogcsys.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "libfat/fat.h"
|
|
|
|
#include "MD5.h"
|
|
#include "banner.h"
|
|
#include "openingbnr.h"
|
|
#include "../ramdisk/ramdisk.h"
|
|
#include "../listfiles.h"
|
|
|
|
u16 be16(const u8 *p)
|
|
{
|
|
return (p[0] << 8) | p[1];
|
|
}
|
|
|
|
u32 be32(const u8 *p)
|
|
{
|
|
return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
|
|
}
|
|
|
|
u64 be64(const u8 *p)
|
|
{
|
|
return ((u64)be32(p) << 32) | be32(p + 4);
|
|
}
|
|
|
|
u64 be34(const u8 *p)
|
|
{
|
|
return 4 * (u64)be32(p);
|
|
}
|
|
|
|
void wbe16(u8 *p, u16 x)
|
|
{
|
|
p[0] = x >> 8;
|
|
p[1] = x;
|
|
}
|
|
|
|
void wbe32(u8 *p, u32 x)
|
|
{
|
|
wbe16(p, x >> 16);
|
|
wbe16(p + 2, x);
|
|
}
|
|
|
|
void wbe64(u8 *p, u64 x)
|
|
{
|
|
wbe32(p, x >> 32);
|
|
wbe32(p + 4, x);
|
|
}
|
|
|
|
void md5(u8 *data, u32 len, u8 *hash)
|
|
{
|
|
MD5(hash, data, len);
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
u8 zeroes[0x40];
|
|
u32 imet; // "IMET"
|
|
u8 zero_six_zero_three[8]; // fixed, unknown purpose
|
|
u32 sizes[3];
|
|
u32 flag1;
|
|
u16 name_jp[0x2a]; // might be empty
|
|
u16 name_en[0x2a];
|
|
u16 name_de[0x2a];
|
|
u16 name_fr[0x2a];
|
|
u16 name_es[0x2a];
|
|
u16 name_it[0x2a];
|
|
u16 name_nl[0x2a];
|
|
u8 zeroes_2[0x348];
|
|
u8 crypto[0x10];
|
|
} imet_data_t;
|
|
|
|
typedef struct {
|
|
u32 imd5_tag; // 0x494D4435 "IMD5";
|
|
u32 size; // size of the rest of part B, starting from next field.
|
|
u8 zeroes[8];
|
|
u8 md5[16];
|
|
u32 payload_tag; // 0x4C5A3737 "LZ77" if this is lz77
|
|
u32 payload_data;
|
|
} imd5_header_t;
|
|
|
|
typedef struct
|
|
{
|
|
u16 type;
|
|
u16 name_offset;
|
|
u32 data_offset; // == absolut offset från U.8- headerns början
|
|
u32 size; // last included file num for directories
|
|
} U8_node;
|
|
|
|
typedef struct
|
|
{
|
|
u32 tag; // 0x55AA382D "U.8-"
|
|
u32 rootnode_offset; // offset to root_node, always 0x20.
|
|
u32 header_size; // size of header from root_node to end of string table.
|
|
u32 data_offset; // offset to data -- this is rootnode_offset + header_size, aligned to 0x40.
|
|
u8 zeroes[16];
|
|
} U8_archive_header;
|
|
|
|
static int write_file(void* data, size_t size, char* name)
|
|
{
|
|
size_t written=0;
|
|
FILE *out;
|
|
out = fopen(name, "wb");
|
|
if(out)
|
|
{
|
|
written = fwrite(data, 1, size, out);
|
|
fclose(out);
|
|
}
|
|
return (written == size) ? 1 : -1;
|
|
}
|
|
|
|
u8* decompress_lz77(u8 *data, size_t data_size, size_t* decompressed_size)
|
|
{
|
|
u8 *data_end;
|
|
u8 *decompressed_data;
|
|
size_t unpacked_size;
|
|
u8 *in_ptr;
|
|
u8 *out_ptr;
|
|
u8 *out_end;
|
|
|
|
in_ptr = data;
|
|
data_end = data + data_size;
|
|
|
|
// Assume this for now and grow when needed
|
|
unpacked_size = data_size;
|
|
|
|
decompressed_data = malloc(unpacked_size);
|
|
out_end = decompressed_data + unpacked_size;
|
|
|
|
out_ptr = decompressed_data;
|
|
|
|
while (in_ptr < data_end) {
|
|
int bit;
|
|
u8 bitmask = *in_ptr;
|
|
|
|
in_ptr++;
|
|
for (bit = 0x80; bit != 0; bit >>= 1) {
|
|
if (bitmask & bit) {
|
|
// Next section is compressed
|
|
u8 rep_length;
|
|
u16 rep_offset;
|
|
|
|
rep_length = (*in_ptr >> 4) + 3;
|
|
rep_offset = *in_ptr & 0x0f;
|
|
in_ptr++;
|
|
rep_offset = *in_ptr | (rep_offset << 8);
|
|
in_ptr++;
|
|
if (out_ptr-decompressed_data < rep_offset) {
|
|
return NULL;
|
|
}
|
|
|
|
for ( ; rep_length > 0; rep_length--) {
|
|
*out_ptr = out_ptr[-rep_offset-1];
|
|
out_ptr++;
|
|
if (out_ptr >= out_end) {
|
|
// Need to grow buffer
|
|
decompressed_data = realloc(decompressed_data, unpacked_size*2);
|
|
out_ptr = decompressed_data + unpacked_size;
|
|
unpacked_size *= 2;
|
|
out_end = decompressed_data + unpacked_size;
|
|
}
|
|
}
|
|
} else {
|
|
// Just copy byte
|
|
*out_ptr = *in_ptr;
|
|
out_ptr++;
|
|
if (out_ptr >= out_end) {
|
|
// Need to grow buffer
|
|
decompressed_data = realloc(decompressed_data, unpacked_size*2);
|
|
out_ptr = decompressed_data + unpacked_size;
|
|
unpacked_size *= 2;
|
|
out_end = decompressed_data + unpacked_size;
|
|
}
|
|
in_ptr++;
|
|
}
|
|
}
|
|
}
|
|
|
|
*decompressed_size = (out_ptr - decompressed_data);
|
|
return decompressed_data;
|
|
}
|
|
|
|
static int write_imd5_lz77(u8* data, size_t size, char* outname)
|
|
{
|
|
imd5_header_t* header = (imd5_header_t*) data;
|
|
u32 tag;
|
|
u32 size_in_imd5;
|
|
u8 md5_calc[16];
|
|
u8 *decompressed_data;
|
|
size_t decompressed_size;
|
|
|
|
tag = be32((u8*) &header->imd5_tag);
|
|
if (tag != 0x494D4435) {
|
|
return -4;
|
|
}
|
|
|
|
md5(data+32, size-32, md5_calc);
|
|
if (memcmp(&header->md5, md5_calc, 0x10)) {
|
|
return -5;
|
|
}
|
|
|
|
size_in_imd5 = be32((u8*) &header->size);
|
|
if (size_in_imd5 != size - 32) {
|
|
return -6;
|
|
}
|
|
|
|
tag = be32((u8*) &header->payload_tag);
|
|
if (tag == 0x4C5A3737) {
|
|
// "LZ77" - uncompress
|
|
decompressed_data = decompress_lz77(data + sizeof(imd5_header_t), size - sizeof(imd5_header_t), &decompressed_size);
|
|
if(decompressed_data == NULL)
|
|
return -7;
|
|
write_file(decompressed_data, decompressed_size, outname);
|
|
//printf(", uncompressed %d bytes, md5 ok", decompressed_size);
|
|
|
|
free(decompressed_data);
|
|
} else {
|
|
write_file(&header->payload_tag, size-32, outname);
|
|
//printf(", md5 ok");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int do_U8_archive(FILE *fp)
|
|
{
|
|
U8_archive_header header;
|
|
U8_node root_node;
|
|
u32 tag;
|
|
u32 num_nodes;
|
|
U8_node* nodes;
|
|
u8* string_table;
|
|
size_t rest_size;
|
|
unsigned int i;
|
|
u32 data_offset;
|
|
u32 current_offset;
|
|
u16 dir_stack[16];
|
|
int dir_index = 0;
|
|
|
|
fread(&header, 1, sizeof header, fp);
|
|
tag = be32((u8*) &header.tag);
|
|
if (tag != 0x55AA382D) {
|
|
return -1;
|
|
}
|
|
|
|
fread(&root_node, 1, sizeof(root_node), fp);
|
|
num_nodes = be32((u8*) &root_node.size) - 1;
|
|
//printf("Number of files: %d\n", num_nodes);
|
|
|
|
nodes = malloc(sizeof(U8_node) * (num_nodes));
|
|
fread(nodes, 1, num_nodes * sizeof(U8_node), fp);
|
|
|
|
data_offset = be32((u8*) &header.data_offset);
|
|
rest_size = data_offset - sizeof(header) - (num_nodes+1)*sizeof(U8_node);
|
|
|
|
string_table = malloc(rest_size);
|
|
fread(string_table, 1, rest_size, fp);
|
|
current_offset = data_offset;
|
|
|
|
for (i = 0; i < num_nodes; i++) {
|
|
U8_node* node = &nodes[i];
|
|
u16 type = be16((u8*)&node->type);
|
|
u16 name_offset = be16((u8*)&node->name_offset);
|
|
u32 my_data_offset = be32((u8*)&node->data_offset);
|
|
u32 size = be32((u8*)&node->size);
|
|
char* name = (char*) &string_table[name_offset];
|
|
u8* file_data;
|
|
|
|
if (type == 0x0100) {
|
|
// Directory
|
|
mkdir(name, 0777);
|
|
chdir(name);
|
|
dir_stack[++dir_index] = size;
|
|
//printf("%*s%s/\n", dir_index, "", name);
|
|
} else {
|
|
// Normal file
|
|
u8 padding[32];
|
|
|
|
if (type != 0x0000) {
|
|
free(string_table);
|
|
return -2;
|
|
}
|
|
|
|
if (current_offset < my_data_offset) {
|
|
int diff = my_data_offset - current_offset;
|
|
|
|
if (diff > 32) {
|
|
free(string_table);
|
|
return -3;
|
|
}
|
|
fread(padding, 1, diff, fp);
|
|
current_offset += diff;
|
|
}
|
|
|
|
file_data = malloc(size);
|
|
fread(file_data, 1, size, fp);
|
|
//printf("%*s %s (%d bytes", dir_index, "", name, size);
|
|
int result;
|
|
result = write_imd5_lz77(file_data, size, name);
|
|
if(result < 0)
|
|
{free(string_table);
|
|
return result;
|
|
}
|
|
//printf(")\n");
|
|
current_offset += size;
|
|
}
|
|
|
|
while (dir_stack[dir_index] == i+2 && dir_index > 0) {
|
|
chdir("..");
|
|
dir_index--;
|
|
}
|
|
}
|
|
free(string_table);
|
|
return 0;
|
|
}
|
|
|
|
static void do_imet_header(FILE *fp)
|
|
{
|
|
imet_data_t header;
|
|
|
|
fread(&header, 1, sizeof header, fp);
|
|
|
|
write_file(&header, sizeof(header), "header.imet");
|
|
}
|
|
|
|
void do_U8_archivebanner(FILE *fp)
|
|
{
|
|
U8_archive_header header;
|
|
U8_node root_node;
|
|
u32 tag;
|
|
u32 num_nodes;
|
|
U8_node* nodes;
|
|
u8* string_table;
|
|
size_t rest_size;
|
|
unsigned int i;
|
|
u32 data_offset;
|
|
u16 dir_stack[16];
|
|
int dir_index = 0;
|
|
|
|
fread(&header, 1, sizeof header, fp);
|
|
tag = be32((u8*) &header.tag);
|
|
if (tag != 0x55AA382D) {
|
|
//printf("No U8 tag");
|
|
exit(0);
|
|
}
|
|
|
|
fread(&root_node, 1, sizeof(root_node), fp);
|
|
num_nodes = be32((u8*) &root_node.size) - 1;
|
|
printf("Number of files: %d\n", num_nodes);
|
|
|
|
nodes = malloc(sizeof(U8_node) * (num_nodes));
|
|
fread(nodes, 1, num_nodes * sizeof(U8_node), fp);
|
|
|
|
data_offset = be32((u8*) &header.data_offset);
|
|
rest_size = data_offset - sizeof(header) - (num_nodes+1)*sizeof(U8_node);
|
|
|
|
string_table = malloc(rest_size);
|
|
fread(string_table, 1, rest_size, fp);
|
|
|
|
for (i = 0; i < num_nodes; i++) {
|
|
U8_node* node = &nodes[i];
|
|
u16 type = be16((u8*)&node->type);
|
|
u16 name_offset = be16((u8*)&node->name_offset);
|
|
u32 my_data_offset = be32((u8*)&node->data_offset);
|
|
u32 size = be32((u8*)&node->size);
|
|
char* name = (char*) &string_table[name_offset];
|
|
u8* file_data;
|
|
|
|
if (type == 0x0100) {
|
|
// Directory
|
|
mkdir(name, 0777);
|
|
chdir(name);
|
|
dir_stack[++dir_index] = size;
|
|
//printf("%*s%s/\n", dir_index, "", name);
|
|
} else {
|
|
// Normal file
|
|
|
|
if (type != 0x0000) {
|
|
printf("Unknown type");
|
|
exit(0);
|
|
}
|
|
|
|
fseek(fp, my_data_offset, SEEK_SET);
|
|
file_data = malloc(size);
|
|
fread(file_data, 1, size, fp);
|
|
write_file(file_data, size, name);
|
|
free(file_data);
|
|
//printf("%*s %s (%d bytes)\n", dir_index, "", name, size);
|
|
}
|
|
|
|
while (dir_stack[dir_index] == i+2 && dir_index > 0) {
|
|
chdir("..");
|
|
dir_index--;
|
|
}
|
|
}
|
|
free(string_table);
|
|
}
|
|
|
|
int extractbnrfile(const char * filepath, const char * destpath)
|
|
{
|
|
int ret = -1;
|
|
FILE *fp = fopen(filepath, "rb");
|
|
if(fp)
|
|
{
|
|
subfoldercreate(destpath);
|
|
chdir(destpath);
|
|
|
|
do_imet_header(fp);
|
|
ret = do_U8_archive(fp);
|
|
|
|
fclose(fp);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int unpackBin(const char * filename,const char * outdir)
|
|
{
|
|
FILE *fp = fopen(filename,"rb");;
|
|
if(fp)
|
|
{
|
|
subfoldercreate(outdir);
|
|
chdir(outdir);
|
|
|
|
do_U8_archivebanner(fp);
|
|
fclose(fp);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define TMP_PATH(s) "BANNER:/dump"s
|
|
//#define TMP_PATH(s) "SD:/dump"s
|
|
|
|
int unpackBanner(const u8 *gameid, int what, const char *outdir)
|
|
{
|
|
|
|
char path[256];
|
|
if(!ramdiskMount("BANNER", NULL)) return -1;
|
|
|
|
subfoldercreate(TMP_PATH("/"));
|
|
s32 ret = dump_banner(gameid, TMP_PATH("/opening.bnr"));
|
|
if (ret != 1)
|
|
{
|
|
ret = -1;
|
|
goto error2;
|
|
}
|
|
|
|
ret = extractbnrfile(TMP_PATH("/opening.bnr"), TMP_PATH("/"));
|
|
if (ret != 0)
|
|
{
|
|
ret = -1;
|
|
goto error2;
|
|
}
|
|
|
|
if(what & UNPACK_BANNER_BIN)
|
|
{
|
|
snprintf(path, sizeof(path),"%sbanner/", outdir);
|
|
ret = unpackBin(TMP_PATH("/meta/banner.bin"), path);
|
|
if (ret != 1)
|
|
{
|
|
ret = -1;
|
|
goto error2;
|
|
}
|
|
}
|
|
if(what & UNPACK_ICON_BIN)
|
|
{
|
|
snprintf(path, sizeof(path),"%sicon/", outdir);
|
|
ret = unpackBin(TMP_PATH("/meta/icon.bin"), path);
|
|
if (ret != 1)
|
|
{
|
|
ret = -1;
|
|
goto error2;
|
|
}
|
|
}
|
|
if(what & UNPACK_SOUND_BIN)
|
|
{
|
|
snprintf(path, sizeof(path),"%ssound.bin", outdir);
|
|
FILE *fp = fopen(TMP_PATH("/meta/sound.bin"), "rb");
|
|
if(fp)
|
|
{
|
|
size_t size;
|
|
u8 *data;
|
|
fseek(fp, 0, SEEK_END);
|
|
size = ftell(fp);
|
|
if(!size)
|
|
{
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
fseek(fp, 0, SEEK_SET);
|
|
data = (u8 *)malloc(size);
|
|
if(!data)
|
|
{
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
if(fread(data, 1, size, fp) != size)
|
|
{
|
|
ret = -1;
|
|
goto error;
|
|
}
|
|
ret = write_file(data, size, path);
|
|
}
|
|
error: fclose(fp);
|
|
}
|
|
ramdiskUnmount("BANNER");
|
|
error2:
|
|
if(ret < 0)
|
|
return ret;
|
|
return 1;
|
|
}
|