diff options
Diffstat (limited to 'project/dclib/lib-dol.h')
| -rw-r--r-- | project/dclib/lib-dol.h | 517 |
1 files changed, 517 insertions, 0 deletions
diff --git a/project/dclib/lib-dol.h b/project/dclib/lib-dol.h new file mode 100644 index 0000000..3197bcc --- /dev/null +++ b/project/dclib/lib-dol.h @@ -0,0 +1,517 @@ + +/*************************************************************************** + * * + * _____ ____ * + * | __ \ / __ \ _ _ _____ * + * | | \ \ / / \_\ | | | | _ \ * + * | | \ \| | | | | | |_| | * + * | | | || | | | | | ___/ * + * | | / /| | __ | | | | _ \ * + * | |__/ / \ \__/ / | |___| | |_| | * + * |_____/ \____/ |_____|_|_____/ * + * * + * Wiimms source code library * + * * + *************************************************************************** + * * + * Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de> * + * * + *************************************************************************** + * * + * This program 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 2 of the License, or * + * (at your option) any later version. * + * * + * This program 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. * + * * + * See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt * + * * + ***************************************************************************/ + +#ifndef DC_LIB_DOL_H +#define DC_LIB_DOL_H 1 + +#define _GNU_SOURCE 1 +#include "dclib-basics.h" + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// DOL: defs & structs /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define DOL_N_TEXT_SECTIONS 7 +#define DOL_N_DATA_SECTIONS 11 +#define DOL_N_SECTIONS 18 + +#define DOL_IDX_BSS DOL_N_SECTIONS // alias for BSS +#define DOL_IDX_ENTRY (DOL_N_SECTIONS+1) // alias for ENTRY +#define DOL_NN_SECTIONS (DOL_N_SECTIONS+2) // N + aliase + +#define DOL_HEADER_SIZE 0x100 + +//----------------------------------------------------------------------------- + +#define ASM_NOP 0x60000000 + +//----------------------------------------------------------------------------- + +static int IsDolTextSection ( uint section ) + { return section < DOL_N_TEXT_SECTIONS; } + +static bool IsDolDataSection ( uint section ) + { return section - DOL_N_TEXT_SECTIONS < DOL_N_DATA_SECTIONS; } + +//----------------------------------------------------------------------------- +// [[dol_header_t]] + +typedef struct dol_header_t +{ + /* 0x00 */ u32 sect_off [DOL_N_SECTIONS]; // file offset + /* 0x48 */ u32 sect_addr[DOL_N_SECTIONS]; // virtual address + /* 0x90 */ u32 sect_size[DOL_N_SECTIONS]; // section size + /* 0xd8 */ u32 bss_addr; // BSS address + /* 0xdc */ u32 bss_size; // BSS size + /* 0xe0 */ u32 entry_addr; // entry point + /* 0xe4 */ u8 padding[DOL_HEADER_SIZE-0xe4]; +} +__attribute__ ((packed)) dol_header_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[dol_sect_info_t]] + +typedef struct dol_sect_info_t +{ + int section; // section index, <0: invalid + char name[4]; // name of section + u32 off; // file offset of data + u32 addr; // image address + u32 size; // size of section + bool sect_valid; // true: section is valid + bool data_valid; // true: data is valid (size>0 and inside DOL file) + bool hash_valid; // true: 'hash' is valid + u8 *data; // NULL (data_valid=0) or pointer to data (data_valid=1) + sha1_hash_t hash; // SHA1 hash of data +} +dol_sect_info_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[dol_sect_select_t]] + +typedef struct dol_sect_select_t +{ + int find_mode; // mode for xFindFirstFreeDolSection(), <0: skip this + int sect_idx; // >=0: section, <0: auto select + char name[4]; // a name based on 'sect_idx' and 'find_mode' + u32 addr; // address of section, if 0: use DATA[0x10] + ccp fname; // file name + bool use_param; // true: write params (entry and '.dol' section) + + u8 *data; // not NULL: data, alloced + uint size; // >0: size of 'data' + u32 offset; // last used file offset (temporary) +} +dol_sect_select_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[dol_sect_addr_t]] + +typedef struct dol_sect_addr_t +{ + //--- source info + u32 addr; // address of data + u32 size; // size of data + + //--- search info + int section; // section index, <0: invalid + char sect_name[4]; // empty or name of found section + u32 sect_addr; // NULL or section address + u32 sect_offset; // NULL or offset in found section + u32 sect_size; // NULL or size of found section +} +dol_sect_addr_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// DOL: Interface /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void ntoh_dol_header ( dol_header_t * dest, const dol_header_t * src ); +void hton_dol_header ( dol_header_t * dest, const dol_header_t * src ); +bool IsDolHeader ( const void *data, uint data_size, uint file_size ); + +extern const char dol_section_name[DOL_NN_SECTIONS+1][4]; +static inline ccp GetDolSectionName ( uint section ) +{ + return section < DOL_NN_SECTIONS ? dol_section_name[section] : 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool GetDolSectionInfo +( + dol_sect_info_t * ret_info, // valid pointer: returned data + const dol_header_t *dol_head, // valid DOL header + uint file_size, // (file) size of 'data' + uint section // 0 .. DOL_NN_SECTIONS + // (7*TEXT, 11*DATA, BSS, ENTRY ) +); + +//----------------------------------------------------------------------------- + +bool FindFirstFreeDolSection +( + // returns TRUE on found + + dol_sect_info_t *info, // result + const dol_header_t *dh, // DOL header to analyse + uint mode // 0: search all sections (TEXT first) + // 1: search only TEXT sections + // 2: search only DATA sections + // 3: search all sections (DATA first) +); + +//----------------------------------------------------------------------------- + +bool FindDolSectionBySelector +( + // returns TRUE on found + + dol_sect_info_t *info, // result + const dol_header_t *dh, // DOL header to analyse + const dol_sect_select_t *dss // DOL section selector +); + +//----------------------------------------------------------------------------- + +u32 FindFreeSpaceDOL +( + // return address or NULL on not-found + + const dol_header_t *dol_head, // valid DOL header + u32 addr_beg, // first possible address + u32 addr_end, // last possible address + u32 size, // minimal size + u32 align, // aligning + u32 *space // not NULL: store available space here +); + +//----------------------------------------------------------------------------- + +u32 FindFreeBssSpaceDOL +( + // return address or NULL on not-found + + const dol_header_t *dol_head, // valid DOL header + u32 size, // min size + u32 align, // aligning + u32 *space // not NULL: store available space here +); + +/////////////////////////////////////////////////////////////////////////////// + +void DumpDolHeader +( + FILE * f, // dump to this file + int indent, // indention + const dol_header_t *dol_head, // valid DOL header + uint file_size, // NULL or size of file + uint print_mode // bit field: + // 1: print file map + // 2: print virtual mem map + // 4: print delta table +); + +/////////////////////////////////////////////////////////////////////////////// + +int GetDolSectionAddr +( + // returns dsa->section + dol_sect_addr_t *dsa, // result: section address info + const dol_header_t *dol_head, // valid DOL header + u32 addr, // address to search + u32 size // >0: wanted size +); + +//----------------------------------------------------------------------------- + +ccp GetDolSectionAddrInfo +( + // returns GetCircBuf() or EmptyString on error + const dol_header_t *dol_head, // valid DOL header + u32 addr, // address to search + u32 size // >0: wanted size +); + +/////////////////////////////////////////////////////////////////////////////// + +u32 GetDolOffsetByAddr +( + const dol_header_t *dol_head, // valid DOL header + u32 addr, // address to search + u32 size, // >0: wanted size + u32 *valid_size // not NULL: return valid size +); + +/////////////////////////////////////////////////////////////////////////////// + +u32 GetDolAddrByOffset +( + const dol_header_t *dol_head, // valid DOL header + u32 off, // address to search + u32 size, // >0: wanted size + u32 *valid_size // not NULL: return valid size +); + +/////////////////////////////////////////////////////////////////////////////// + +uint AddDolAddrByOffset +( + const dol_header_t *dol_head, // valid DOL header + MemMap_t *mm, // valid destination mem map, not cleared + bool use_tie, // TRUE: use InsertMemMapTie() + u32 off, // address to search + u32 size // size, may overlay multiple sections +); + +/////////////////////////////////////////////////////////////////////////////// + +uint TranslateDolOffsets +( + const dol_header_t *dol_head, // valid DOL header + MemMap_t *mm, // valid destination mem map, not cleared + bool use_tie, // TRUE: use InsertMemMapTie() + const MemMap_t *mm_off // NULL or mem map with offsets +); + +/////////////////////////////////////////////////////////////////////////////// + +uint TranslateAllDolOffsets +( + const dol_header_t *dol_head, // valid DOL header + MemMap_t *mm, // valid destination mem map, not cleared + bool use_tie // TRUE: use InsertMemMapTie() +); + +/////////////////////////////////////////////////////////////////////////////// + +uint TranslateDolSections +( + const dol_header_t *dol_head, // valid DOL header + MemMap_t *mm, // valid destination mem map, not cleared + bool use_tie, // TRUE: use InsertMemMapTie() + uint dol_sections // bitfield of sections +); + +/////////////////////////////////////////////////////////////////////////////// + +uint CountOverlappedDolSections +( + // returns the number of overlapped section by [addr,size] + + const dol_header_t *dol_head, // valid DOL header + u32 addr, // address to search + u32 size // size of addr to verify +); + +/////////////////////////////////////////////////////////////////////////////// + +u32 FindDolAddressOfVBI +( + // search in available data and return NULL if not found + + cvp data, // DOL data beginning with dol_header_t + uint data_size // size of 'data' +); + +/////////////////////////////////////////////////////////////////////////////// + +char * ScanDolSectionName +( + // returns the first uninterpreted character + + ccp arg, // comma/space separated names + int *ret_section, // not NULL: return section index + // <0: error / >=0: section index + enumError *ret_err // not NULL: return error code +); + +//----------------------------------------------------------------------------- + +uint ScanDolSectionList +( + // return a bitfield as section list + + ccp arg, // comma/space separated names + enumError *ret_err // not NULL: return status +); + +//----------------------------------------------------------------------------- + +ccp DolSectionList2Text ( uint sect_list ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// add/remove DOL sections /////////////// +/////////////////////////////////////////////////////////////////////////////// + +uint CompressDOL +( + // return: size of compressed DOL (inline replaced) + + dol_header_t *dol, // valid dol header + FILE *log // not NULL: print memmap to this file +); + +//----------------------------------------------------------------------------- + +uint RemoveDolSections +( + // return: 0:if not modifed, >0:size of compressed DOL + + dol_header_t *dol, // valid dol header + uint stay, // bit field of sections (0..17): SET => don't remove + uint *res_stay, // not NULL: store bit field of vlaid sections here + FILE *log // not NULL: print memmap to this file +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Gecko Code Handler /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define GCH_MAGIC_NUM 0x47044348 + +#define GCT_MAGIC8_NUM 0x00d0c0de00d0c0deull +#define GCT_TERM_NUM 0xf000000000000000ull +#define GCT_SEP_NUM1 0xf0000001u +#define GCT_REG_OFFSET 8 + +/////////////////////////////////////////////////////////////////////////////// +// [[gch_header_t]] + +typedef struct gch_header_t +{ + // big endian! + + u32 magic; // magic: 'G\x{04}CH' (Gecko Code Handler) + u32 addr; // address of new section + u32 size; // size of code section, file size must be >= 'size' + // a cheat section may follow + u32 vbi_entry; // >0: entry point for VBI interrupts + + u8 data[]; // usually start of code handler +} +__attribute__ ((packed)) gch_header_t; + +/////////////////////////////////////////////////////////////////////////////// + +bool IsValidGCH +( + const gch_header_t *gh, // valid header + uint file_size // size of file +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// Wiimms Code Handler /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define WCH_MAGIC_NUM 0x57054348 + +/////////////////////////////////////////////////////////////////////////////// +// [[wch_segment_t]] + +typedef struct wch_segment_t +{ + // big endian! + + u32 type; // 'T': text section + // 'D': data section + // 'S': any section, try data first, then text + // 'P': patch data => patch main.dol + // 0 : end of segment list + + u32 addr; // address, where the data is stored + u32 size; // size of data + + u32 main_entry; // >0: `main entry point´ + u32 main_entry_old; // >0: store old `main entry point´ at this address + u32 vbi_entry; // >0: `vbi entry point´ + u32 vbi_entry_old; // >0: store old `vbi entry point´ at this address + + u8 data[]; // data, aligned by ALIGN(size,4) + // wch_segment_t // next segment, aligned by ALIGN(size,4) +} +__attribute__ ((packed)) wch_segment_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[wch_header_t]] + +typedef struct wch_header_t +{ + // big endian! + + u32 magic; // magic: 'W\x{05}CH' (Gecko Code Handler) + u32 version; // 0: raw, 1: bzip2 + u32 size; // total size of (uncompressed) segment data + + wch_segment_t segment[]; // first segment +} +__attribute__ ((packed)) wch_header_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[wch_control_t]] + +#define WCH_MAX_SEG 50 + +typedef struct wch_control_t +{ + u8 *temp_data; // not NULL: temporary data, alloced + uint temp_size; // not NULL: size of 'temp_data' + + bool is_valid; // true: data is valid + wch_header_t wh; // decoded header, local endian + + uint n_seg; // number of segments excluding terminator + wch_segment_t seg[WCH_MAX_SEG+1]; // decoded segment headers, local endian + // + special terminator segment (type==0) + u8 *seg_data[WCH_MAX_SEG+1]; // pointer to decoded data for each segment +} +wch_control_t; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef enumError (*DecompressWCH_func) +( + // return TRUE on success + + wch_control_t *wc, // valid data, includes type info + void *data, // source data to decompress + uint size // size of 'data' +); + +/////////////////////////////////////////////////////////////////////////////// + +ccp DecodeWCH +( + // returns NULL on success, or a short error message + + wch_control_t *wc, // store only, (initialized) + void *data, // source data, modified if type != 0 + uint size, // size of 'data' + DecompressWCH_func decompress // NULL or decompression function +); + +void ResetWCH ( wch_control_t * wc ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// E N D /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#endif // DC_LIB_DOL_H 1 |