int dump_plot(const char *input_filename, const char *output_dir)
{
char output_filename[_MAX_PATH];
char drive[_MAX_DRIVE], dir[_MAX_DIR], fn[_MAX_FNAME];
FILE *input_fp;
pointer_struct ptr;
int ret;
if ((input_fp=fopen(input_filename, "rb"))== NULL)
{
printf("Could not open input file\n");
return -1;
}
ptr.offset = 0;
fseek(input_fp, 0, SEEK_END);
ptr.size = ftell(input_fp);
fseek(input_fp, 0, SEEK_SET);
_splitpath(output_dir, drive, dir, fn, NULL);
strcat(dir, fn);
// generate output filename
_makepath(output_filename, drive, dir, "plot", ".sjs");
ret = dump_section(input_fp, &ptr, output_filename);
fclose(input_fp);
return ret;
}
static int dump_entry (FILE * f, struct ConfigVTable * h, SectionHandle s,
unsigned int indent, const SectionEntry * entry)
{
int ret = 1;
switch (entry->type)
{
case SE_SECTION:
{
SectionHandle newsec;
fprintf (f, "%s { \n", entry->name);
ret = mymin(ret, cf_openSection (h, s, entry->name, &newsec));
if (ret >= 0)
{
ret = mymin (dump_section (f, h, newsec, indent + 2), ret);
show_indent (f, indent);
fprintf (f, "}\n");
ret = mymin (ret, cf_closeSection (h, newsec));
}
break;
}
case SE_KEY:
{
char buf[255];
ret = mymin (ret, cf_getKey (h, s, entry->name, &buf[0], sizeof(buf)));
if (ret >= 0)
{
fprintf (f, "%s = \"%s\";\n", entry->name, buf);
}
break;
}
case SE_MULTIKEY:
{
char ** ptrs;
size_t size;
size_t j;
ret = mymin (ret, cf_getMultiKey (h, s, entry->name, &ptrs, &size));
if (ret >= 0)
{
fprintf (f,"%s = (", entry->name);
for (j=0; j<size; ++j)
{
fprintf (f,"\"%s\" ", (ptrs[j] ? ptrs[j] : ""));
free (ptrs[j]);
if ((j+1) < size)
fprintf (f,", ");
}
fprintf (f, ");\n");
free (ptrs);
}
}
}
return ret;
}
int txtfile_writeConfig (struct ConfigVTable * cf, SectionHandle h, FILE * f, char ** err)
{
int ret;
assert(err);
assert(f);
*err = 0;
if ((ret = dump_section (f, cf, h, 0)) < 0)
{
*err = strdup ("Error accessing config tree!");
return ret;
}
return ret;
}
int main(int argc, char* argv[])
{
if (argc!=2) {
show_usage();
return 0;
}
//while(true) {
MAPPED_FILE view = {0};
if( 0 != map_file( argv[1], &view ) ) {
printf( "open file failed: %s\n", argv[2]);
return -1;
}
int pe = pe_open((const char*)view.data, view.size);
if (pe == INVALID_PE) {
printf( "file is not pe format");
return -1;
}
dump_entry(pe);
dump_version(pe);
dump_section(pe);
dump_export(pe);
dump_import(pe);
dump_overlay(pe);
dump_resource(pe);
char path[256] = {0};
strcat(getcwd(path, sizeof(path) - 1), "\\sample.ico");
dump_icon(pe, path);
pe_close(pe);
unmap_file(&view);
//}
system("pause");
return 0;
}
static void
_on_bus_message (GstBus * bus, GstMessage * message, GMainLoop * mainloop)
{
/* g_printf ("Got message %s\n", GST_MESSAGE_TYPE_NAME (message)); */
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:
case GST_MESSAGE_EOS:
g_main_loop_quit (mainloop);
break;
case GST_MESSAGE_ELEMENT:
{
GstMpegTsSection *section;
if ((section = gst_message_parse_mpegts_section (message))) {
g_print
("Got section: PID:0x%04x type:%s (table_id 0x%02x (%s)) at offset %"
G_GUINT64_FORMAT "\n", section->pid,
enum_name (GST_TYPE_MPEG_TS_SECTION_TYPE, section->section_type),
section->table_id, enum_name (GST_TYPE_MPEG_TS_SECTION_TABLE_ID,
section->table_id), section->offset);
if (!section->short_section) {
g_print
(" subtable_extension:0x%04x, version_number:0x%02x\n",
section->subtable_extension, section->version_number);
g_print
(" section_number:0x%02x last_section_number:0x%02x crc:0x%08x\n",
section->section_number, section->last_section_number,
section->crc);
}
dump_section (section);
g_printf ("\n\n");
gst_mpegts_section_unref (section);
}
break;
}
default:
break;
}
}
int dump_d00(const char *input_filename, const char *output_dir)
{
char drive[_MAX_DRIVE], dir[_MAX_DIR], fn[_MAX_FNAME];
FILE *input_fp;
int done = 0;
unsigned long num_offsets=0;
unsigned long i;
pointer_struct *offset_data;
// Main program
if (fopen_s(&input_fp, input_filename, "rb") != 0)
{
printf("Could not open input file\n");
return -1;
}
// figure out how many text sections to dump
fread((void *)&num_offsets, 4, 1, input_fp);
num_offsets = DoubleWordSwap(num_offsets);
// printf("number of offsets = %x - %d\n", num_offsets, num_offsets);
// allocate and grab offset list
if ((offset_data = (pointer_struct *)malloc(sizeof(pointer_struct) * num_offsets)) == NULL)
{
printf("Unable to allocate offset/size list\n");
fclose(input_fp);
return -2;
}
for (i = 0; i < num_offsets; i++)
{
fread((void *)&offset_data[i].offset, 4, 1, input_fp);
fread((void *)&offset_data[i].size, 4, 1, input_fp);
offset_data[i].offset = DoubleWordSwap(offset_data[i].offset) * 0x800;
offset_data[i].size = DoubleWordSwap(offset_data[i].size);
// printf("offset_data[%d] offset = %08x size = %08x\n", i, offset_data[i].offset, offset_data[i].size);
}
for (i = 0; i < num_offsets; i++)
{
unsigned long temp_long=0;
unsigned long temp_long2=0;
// figure out the absolute offset of the text section
fseek(input_fp, offset_data[i].offset, SEEK_SET);
fread((void *)&temp_long, 4, 1, input_fp);
temp_long = DoubleWordSwap(temp_long);
fseek(input_fp, offset_data[i].offset + temp_long + 0x40, SEEK_SET);
fread((void *)&temp_long2, 4, 1, input_fp);
temp_long2 = DoubleWordSwap(temp_long2);
// horray! Now we know the absolute offset of the text section!
offset_data[i].offset += (temp_long + temp_long2);
// Now grab the text section's size
fseek(input_fp, offset_data[i].offset, SEEK_SET);
fread((void *)&offset_data[i].size, 4, 1, input_fp);
offset_data[i].size = DoubleWordSwap(offset_data[i].size);
}
// start a for loop that goes through each offset
for (i = 0; i < num_offsets; i++)
{
char output_filename[_MAX_PATH];
_splitpath(output_dir, drive, dir, fn, NULL);
strcat(dir, fn);
// generate output filename
sprintf(fn, "scen%d\0", i + 1);
_makepath(output_filename, drive, dir, fn, ".sjs");
dump_section(input_fp, &offset_data[i], output_filename);
}
fclose(input_fp);
free(offset_data);
return 0;
}
int main(int argc, char **argv)
{
if ( argc < 2 )
{
printf("fltdump.exe filename.flt [-f]\n -f = dump content of FLAT sections\n");
return 1;
}
if ( argc > 2 && argv[2][0]=='-' && argv[2][1]=='f' )
{ FLAG_DUMP_FLAT=1;}
char* filename_flt = argv[1];
int rv;
if ( (rv=b_file_preload(filename_flt)) <= 0 )
{
fprintf(stderr, "Error load file '%s': loaded %d\n",filename_flt,rv);
return 1;
}
flat = (struct flat_hdr*) b_get_buf();
flat_buf = (unsigned char*)b_get_buf();
char magic[5]; // "CFLA"
memcpy(magic,flat->magic,4);
magic[4]=0;
printf("\nFLT Headers:\n");
printf("->magic %s (flat rev.%d)\n", magic, flat->rev );
if ( memcmp(magic,FLAT_MAGIC_NUMBER,4) ) {
printf("This is not CHDK-FLAT!\n");
return 1;
}
if ( flat->rev != FLAT_VERSION )
{
printf("Bad FLAT revision! It is %d while should be %d\n", flat->rev, FLAT_VERSION);
}
int flat_reloc_count;
flat_reloc_count = (flat->import_start-flat->reloc_start)/sizeof(uint32_t);
int flat_import_count;
flat_import_count = (flat->file_size-flat->import_start)/sizeof(uint32_t);
printf("->entry(.text) 0x%x (size %d)\n", flat->entry, flat->data_start - flat->entry );
printf("->data_start 0x%x (size %d)\n", flat->data_start, flat->bss_start - flat->data_start );
printf("->bss_start 0x%x (size %d)\n", flat->bss_start, flat->reloc_start - flat->bss_start );
printf("->reloc_start 0x%x (size %d)\n", flat->reloc_start, flat->import_start - flat->reloc_start );
printf("->import_start 0x%x (size %d)\n", flat->import_start, flat->file_size - flat->import_start );
printf("\n");
if ( flat->rev == FLAT_VERSION )
{
struct ModuleInfo* _module_info = (struct ModuleInfo*)(flat_buf + flat->_module_info_offset);
if ( _module_info->magicnum != MODULEINFO_V1_MAGICNUM )
{
printf("Malformed module info - bad magicnum!\n");
return 1;
}
if ( _module_info->sizeof_struct != sizeof(struct ModuleInfo) )
{
printf("Malformed module info - bad sizeof!\n");
return 1;
}
printf("\nModule info:\n");
printf("->Module Name: %s\n", get_flat_string(_module_info->moduleName) );
printf("->Module Ver: %d.%d\n", _module_info->module_version.major, _module_info->module_version.minor );
char* branches_str[] = {"any branch","CHDK", "CHDK_DE", "CHDK_SDM", "PRIVATEBUILD"};
int branch = (_module_info->chdk_required_branch>REQUIRE_CHDK_PRIVATEBUILD) ?
REQUIRE_CHDK_PRIVATEBUILD : _module_info->chdk_required_branch;
printf("->Require: %s-build%d. ", branches_str[branch], _module_info->chdk_required_ver );
if ( _module_info->chdk_required_platfid == 0 )
printf("Any platform.\n");
else
printf(" Platform #%d only.\n", _module_info->chdk_required_platfid );
printf("->Description: %s\n", get_flat_string(_module_info->description) );
print_offs("->lib = ", (int)_module_info->lib,"\n");
//print_offs("->_module_loader() = ", (int)_module_info->loader,"\n");
//print_offs("->_module_unloader() = ", (int)_module_info->unloader,"\n");
//print_offs("->_module_can_unload()= ", (int)_module_info->can_unload,"\n");
//print_offs("->_module_exit_alt() = ", (int)_module_info->exit_alt,"\n");
}
if ( !FLAG_DUMP_FLAT )
return 0;
dump_section( "FLT_header", flat_buf, sizeof(struct flat_hdr) );
dump_section( "FLT_text", flat_buf+flat->entry, flat->data_start-flat->entry );
dump_section( "FLT_data", flat_buf+flat->data_start, flat->bss_start-flat->data_start);
dump_section( "FLT_bss", flat_buf+flat->bss_start, flat->reloc_start-flat->bss_start );
int i;
printf("\nDump relocations 0x%x (size=%d):\n",flat->reloc_start,flat_reloc_count*sizeof(uint32_t));
for( i = 0; i< flat_reloc_count; i++)
print_offs("Offs: ",*(int*)(flat_buf+flat->reloc_start+i*sizeof(uint32_t)),"\n");
printf("\nDump imports 0x%x (size=%d):\n",flat->import_start,flat_import_count*sizeof(uint32_t));
uint32_t *new_import_buf = (uint32_t*)(flat_buf+flat->import_start);
for( i = 0; i< flat_import_count; i++)
{
uint32_t idx = new_import_buf[i++];
int cnt = new_import_buf[i] >> 24;
int j;
for (j=0; j<cnt; j++)
{
uint32_t offs = new_import_buf[i++] & 0x00FFFFFF;
print_offs((j==0)?"Offs: ":" ",offs,"");
int addend = *(uint32_t*)(flat_buf+offs);
printf(" = sym_%08x[%s]+0x%x\n",idx,get_import_symbol(idx),addend);
}
}
return 0;
}
/*---------------------------------------------------------------------------*/
int
elfloader_load(char* filename, char* fltfile)
{
struct elf32_ehdr ehdr;
struct elf32_shdr shdr;
struct elf32_shdr strtable;
unsigned int strs;
unsigned int shdrptr;
unsigned int nameptr;
char name[12];
int i;
unsigned short shdrnum, shdrsize;
int ret;
/* Ensure that we have a correct and compatible ELF header. */
ret = b_seek_read( 0, (char *)&ehdr, sizeof(ehdr));
if (ret != sizeof(ehdr)) return ELFFLT_INPUT_ERROR;
if(memcmp(ehdr.e_ident, elf_magic_header, sizeof(elf_magic_header)) != 0) {
PRINTERR(stderr, "ELF header problems\n");
return ELFFLT_BAD_ELF_HEADER;
}
if ( FLAG_VERBOSE )
printf ("Grab section header\n");
// Grab the section header.
shdrptr = ehdr.e_shoff;
ret = b_seek_read( shdrptr, (char *)&shdr, sizeof(shdr));
if (ret != sizeof(shdr)) return ELFFLT_INPUT_ERROR;
shdrsize = ehdr.e_shentsize;
shdrnum = ehdr.e_shnum;
if ( FLAG_VERBOSE )
printf ("Grab string table section\n");
// Grab the string table section for the names of the sections.
ret = b_seek_read( ehdr.e_shoff + shdrsize * ehdr.e_shstrndx,
(char *)&strtable, sizeof(strtable));
if (ret != sizeof(strtable)) return ELFFLT_INPUT_ERROR;
strs = strtable.sh_offset;
/* Parse segments headers to releavant_section entries.
.text = actual code from the ELF file
.data = initialized data
.rodata = contains read-only data
.bss = segment holds the size of the unitialized data segment
.rel.text, .rel.data = relocation information for the contents
of the ".text" and ".data" segments, respectively.
.symtab = symbol table for this file
.strtab = points to the actual string names used by the symbol table.
*/
// Zero size is indicator of unitialized (not found) section
text.size = text.relasize = data.size = data.relasize =
rodata.size = rodata.relasize = symtabsize = strtabsize = 0;
bss.number = data.number = rodata.number = text.number = -1;
shdrptr = ehdr.e_shoff;
for(i = 0; i < shdrnum; ++i) {
ret = b_seek_read( shdrptr, (char *)&shdr, sizeof(shdr));
DEBUGPRINTF("==shdrptr=0x%x, sizeof=%d; size=0x%x\n",shdrptr,sizeof(shdr),shdrsize );
if (ret != sizeof(shdr)) { PRINTERR(stderr, "input error at %s:%d :loaded%d",__FILE__,__LINE__,ret);return ELFFLT_INPUT_ERROR;}
/* The name of the section is contained in the strings table. */
nameptr = strs + shdr.sh_name;
DEBUGPRINTF("==nameptr=%x(%x+%x), size=%d\n",nameptr,strs,shdr.sh_name,sizeof(name) );
ret = b_seek_read( nameptr, name, sizeof(name));
if (ret != sizeof(name)) {PRINTERR(stderr, "input error at %s:%d",__FILE__,__LINE__); return ELFFLT_INPUT_ERROR;}
DEBUGPRINTF("==shdrptr=0x%x, sizeof=%d; size=0x%x\n",shdrptr,sizeof(shdr),shdrsize );
if ( FLAG_DUMP_SECTIONS )
printf ("Section #%d: %-15s [section header 0x%x, offset=0x%x, size %d, vma=0x%x]\n",i,name,shdrptr,
shdr.sh_offset,shdr.sh_size, shdr.sh_addr);
if(strncmp(name, ".text", 5) == 0) {
text.number = i;
text.offset = shdr.sh_offset;
text.size = shdr.sh_size;
text.base_addr = shdr.sh_addr;
} else if(strncmp(name, ".rel.text", 9) == 0) {
text.relaoff = shdr.sh_offset;
text.relasize = shdr.sh_size;
} else if(strncmp(name, ".data", 5) == 0) {
data.number = i;
data.offset = shdr.sh_offset;
data.size = shdr.sh_size;
data.base_addr = shdr.sh_addr;
} else if(strncmp(name, ".rodata", 7) == 0) {
rodata.number = i;
rodata.offset = shdr.sh_offset;
rodata.size = shdr.sh_size;
rodata.base_addr = shdr.sh_addr;
} else if(strncmp(name, ".rel.rodata", 11) == 0) {
rodata.relaoff = shdr.sh_offset;
rodata.relasize = shdr.sh_size;
} else if(strncmp(name, ".rel.data", 9) == 0) {
data.relaoff = shdr.sh_offset;
data.relasize = shdr.sh_size;
} else if(strncmp(name, ".rela.", 6) == 0) {
PRINTERR(stderr,"RELA relocs are not supported.");
return ELFFLT_INPUT_ERROR;
} else if(strncmp(name, ".symtab", 7) == 0) {
symtaboff = shdr.sh_offset;
symtabsize = shdr.sh_size;
} else if(strncmp(name, ".strtab", 7) == 0) {
strtaboff = shdr.sh_offset;
strtabsize = shdr.sh_size;
} else if(strncmp(name, ".bss", 4) == 0) {
bss.size = shdr.sh_size;
bss.number = i;
bss.offset = 0;
}
shdrptr += shdrsize;
}
if(symtabsize == 0) {
PRINTERR(stderr,"No symbol table found.");
return ELFFLT_NO_SYMTAB;
}
if(strtabsize == 0) {
PRINTERR(stderr,"No strings table found.");
return ELFFLT_NO_STRTAB;
}
if(text.size == 0) {
PRINTERR(stderr, "No .text segment found.");
return ELFFLT_NO_TEXT;
}
if ( (text.relasize + rodata.relasize+ data.relasize) <=0 ) {
PRINTERR(stderr,"Found no reloc sections. Please link with -r -d options.\n");
return ELFFLT_UNHANDLED_RELOC;
}
if (bss.size) {
bss.address = (char *)malloc(bss.size);
if (!bss.address) return ELFFLT_OUTPUT_ERROR;
}
if (data.size) {
data.address = (char *)malloc(data.size);
if (!data.address) return ELFFLT_OUTPUT_ERROR;
}
if (text.size) {
text.address = (char *)malloc(text.size);
if (!text.address) return ELFFLT_OUTPUT_ERROR;
}
if (rodata.size) {
rodata.address = (char *)malloc(rodata.size);
if (!rodata.address) return ELFFLT_OUTPUT_ERROR;
}
rodata.name=".rodata";
bss.name=".bss";
text.name=".text";
data.name=".data";
b_seek_read(text.offset, text.address, text.size);
b_seek_read(data.offset, data.address, data.size);
b_seek_read(rodata.offset, rodata.address, rodata.size);
if ( FLAG_DUMP_SOURCE ) {
dump_section( text.name, (unsigned char *)text.address, text.size );
dump_section( data.name, (unsigned char *)data.address, data.size );
dump_section( rodata.name, (unsigned char *)rodata.address, rodata.size );
}
if ( FLAG_DUMP_SYMBOLS ) {
dump_symtable();
}
if ( FLAG_DUMP_SYMBOLS || FLAG_DUMP_SOURCE || FLAG_VERBOSE )
printf("\n\n");
if ( FLAG_VERBOSE )
printf ("Prepare flat\n");
int div0hack_size = sizeof(div0_arm);
int flatmainsize = sizeof(struct flat_hdr)+text.size+div0hack_size+data.size+rodata.size+bss.size;
int flatrelocsize = text.relasize+rodata.relasize+data.relasize;
// Take to account aligning to int32 each section
flatmainsize += align4(text.size) + align4(data.size) + align4(rodata.size) + align4(bss.size);
flat_buf=malloc( flatmainsize+flatrelocsize );
if ( !flat_buf) { PRINTERR(stderr, "fail to malloc flat buf\n"); return ELFFLT_OUTPUT_ERROR;}
memset(flat_buf, 0, flatmainsize+flatrelocsize);
//import is subset of full reloc list, so same count is enough
// but apply multiplier to take into account difference between sizeofs
flat_import_buf=malloc( flatrelocsize* sizeof(import_record_t)/sizeof(reloc_record_t) );
if ( !flat_import_buf) { PRINTERR(stderr, "fail to malloc flat import buf\n"); return ELFFLT_OUTPUT_ERROR;}
memset(flat_import_buf, 0, flatrelocsize);
// Fill flat with sections aligned to int32
flat = (struct flat_hdr*) flat_buf;
if ( FLAG_VERBOSE )
printf(">>elf2flt: load segments\n");
int offset=sizeof(struct flat_hdr);
text.flat_offset = offset;
memcpy( flat_buf+offset, text.address, text.size );
DEBUGPRINTF("load .txt to %x (%x->%x)\n",offset,text.size,text.size+align4(text.size));
offset+=text.size+div0hack_size+align4(text.size);
rodata.flat_offset = offset;
DEBUGPRINTF("load .rodata to %x (%x->%x)\n",offset,rodata.size,rodata.size+align4(rodata.size));
memcpy( flat_buf+offset, rodata.address, rodata.size );
offset+=rodata.size+align4(rodata.size);
data.flat_offset = offset;
DEBUGPRINTF("load .data to %x (%x->%x)\n",offset,data.size,data.size+align4(data.size));
memcpy( flat_buf+offset, data.address, data.size );
offset+=data.size+align4(data.size);
bss.flat_offset = offset;
DEBUGPRINTF(".bss to %x (%x->%x)\n",offset,bss.size,bss.size+align4(bss.size));
DEBUGPRINTF("result=%x\n", flatmainsize);
// Initialize flat headers
memcpy(flat->magic, FLAT_MAGIC_NUMBER, sizeof(flat->magic)); // Set magic (CHDK_FLAT)
flat->rev = FLAT_VERSION;
flat->entry = text.flat_offset;
flat->data_start = rodata.flat_offset;
flat->bss_start = bss.flat_offset;
flat->reloc_start = flatmainsize;
flat_reloc_count = 0;
flat->import_start = 0;
flat_import_count = 0;
flat_reloc = (reloc_record_t*)(flat_buf+flatmainsize);
flat_reloc_cur = flat_reloc;
flat_import_cur = flat_import_buf;
// _div0_arm hack
add_div0_arm();
flag_unsafe_sym = 0;
// Do relocations
ret = relocate_section( &text);
if(ret != ELFFLT_OK)
return ret;
ret = relocate_section( &rodata);
if(ret != ELFFLT_OK)
return ret;
ret = relocate_section( &data);
if(ret != ELFFLT_OK)
return ret;
if ( flag_unsafe_sym )
return ELFFLT_UNSAFE_SYMBOL;
flat->import_start = flat->reloc_start+flat_reloc_count*sizeof(reloc_record_t);
// Init offsets to the entry symbols
if ( FLAG_VERBOSE )
printf(">>elf2flt: lookup entry symbols\n");
flat->_module_info_offset = find_symbol_inflat("_module_info", &data );
if ( flat->_module_info_offset <=0 ) {
PRINTERR(stderr, "No or invalid section of _module_info. This symbol should be initialized as ModuleInfo structure.\n");
return ELFFLT_NO_MODULEINFO;
}
struct ModuleInfo* _module_info = (struct ModuleInfo*) (flat_buf + flat->_module_info_offset);
if ( _module_info->magicnum != MODULEINFO_V1_MAGICNUM )
{
PRINTERR(stderr, "Wrong _module_info->magicnum value. Please check correct filling of this structure\n");
return ELFFLT_NO_MODULEINFO;
}
if ( _module_info->sizeof_struct != sizeof(struct ModuleInfo) )
{
PRINTERR(stderr, "Wrong _module_info->sizeof_struct value. Please check correct filling of this structure\n");
return ELFFLT_NO_MODULEINFO;
}
// Group import relocations
// Input = array of offset/index pairs - one for each address to be relocated to a core CHDK symbol
// Output = list of entries of the form:
// Index, Offset1 | (N<<24), Offset2, ..., OffsetN
// where each offset is a reference to the same core CHDK symbol
uint32_t *new_import_buf = malloc(flat_import_count*3*sizeof(uint32_t));
uint32_t new_import_cnt = 0;
int process = 1;
while (process)
{
process = 0;
for (i=0; i<flat_import_count; i++)
{
if (flat_import_buf[i].offs != 0)
{
process = 1;
int cnt = 0;
uint32_t idx = flat_import_buf[i].importidx;
new_import_buf[new_import_cnt++] = idx;
int pcnt = new_import_cnt;
int j;
for (j=0; j<flat_import_count; j++)
{
if (flat_import_buf[j].importidx == idx)
{
new_import_buf[new_import_cnt++] = flat_import_buf[j].offs;
flat_import_buf[j].offs = 0;
cnt++;
}
}
new_import_buf[pcnt] = (cnt << 24) | new_import_buf[pcnt];
}
}
}
flat->file_size = flat->import_start+new_import_cnt*sizeof(uint32_t);
if ( FLAG_DUMP_FLT_HEADERS ) {
printf("\nFLT Headers:\n");
printf("->entry 0x%x (size %d)\n", flat->entry, flat->data_start - flat->entry );
printf("->data_start 0x%x (size %d)\n", flat->data_start, flat->bss_start - flat->data_start );
printf("->bss_start 0x%x (size %d)\n", flat->bss_start, flat->reloc_start - flat->bss_start );
printf("->reloc_start 0x%x (size %d)\n", flat->reloc_start, flat_reloc_count*sizeof(reloc_record_t) );
printf("->import_start 0x%x (size %d %d)\n", flat->import_start, flat->file_size-flat->import_start, flat_import_count*sizeof(import_record_t) );
printf("\n");
printf("\nModule info:\n");
printf("->Module Name: %s\n", get_flat_string(_module_info->moduleName) );
printf("->Module Ver: %d.%d\n", _module_info->module_version.major, _module_info->module_version.minor );
char* branches_str[] = {"any branch","CHDK", "CHDK_DE", "CHDK_SDM", "PRIVATEBUILD"};
int branch = (_module_info->chdk_required_branch>REQUIRE_CHDK_PRIVATEBUILD) ?
REQUIRE_CHDK_PRIVATEBUILD : _module_info->chdk_required_branch;
printf("->Require: %s-build%d. ", branches_str[branch], _module_info->chdk_required_ver );
if ( _module_info->chdk_required_platfid == 0 )
printf("Any platform.\n");
else
printf(" Platform #%d only.\n", _module_info->chdk_required_platfid );
printf("->Description: %s\n", get_flat_string(_module_info->description) );
print_offs("->lib = ", (int)_module_info->lib,"\n");
//print_offs("->_module_loader() = ", (int)_module_info->loader,"\n");
//print_offs("->_module_unloader() = ", (int)_module_info->unloader,"\n");
//print_offs("->_module_can_unload()= ", (int)_module_info->can_unload,"\n");
//print_offs("->_module_exit_alt() = ", (int)_module_info->exit_alt,"\n");
}
if ( FLAG_DUMP_FLAT ) {
dump_section( "FLT_header", (unsigned char*)flat_buf, sizeof(struct flat_hdr) );
dump_section( "FLT_text", (unsigned char*)flat_buf+flat->entry, flat->data_start-flat->entry );
dump_section( "FLT_data", (unsigned char*)flat_buf+flat->data_start, flat->bss_start-flat->data_start);
dump_section( "FLT_bss", (unsigned char*)flat_buf+flat->bss_start, flat->reloc_start-flat->bss_start );
printf("\nDump relocations 0x%x (size=%d):\n",flat->reloc_start,flat_reloc_count*sizeof(reloc_record_t));
for( i = 0; i< flat_reloc_count; i++)
{
print_offs("Offs: ",*(int*)(flat_buf+flat->reloc_start+i*sizeof(reloc_record_t)), "\n");
}
printf("\nDump imports 0x%x (size=%d):\n",flat->import_start,new_import_cnt*sizeof(uint32_t));
for (i = 0; i< new_import_cnt;)
{
uint32_t idx = new_import_buf[i++];
int cnt = new_import_buf[i] >> 24;
int j;
for (j=0; j<cnt; j++)
{
uint32_t offs = new_import_buf[i++] & 0x00FFFFFF;
print_offs((j==0)?"Offs: ":" ",offs,"");
int addend = *(uint32_t*)(flat_buf+offs);
printf(" = sym_%08x[%s]+0x%x\n",idx,get_import_symbol(idx),addend);
}
}
}
int filesize = flat->file_size;
printf("\n\nOutput file %s (size=%d bytes)\n",fltfile,filesize);
int output_fd = open(fltfile,O_WRONLY|O_CREAT|O_TRUNC|O_BINARY,0777);
i = write(output_fd, flat_buf, flat->import_start);
i = write(output_fd, new_import_buf, new_import_cnt*sizeof(uint32_t));
close(output_fd);
return ELFFLT_OK;
}
void Command::dump_usage(std::ostream &out, bool show_hidden) const
{
std::stringstream ss;
out << std::endl;
ss << get_name() << " - ";
dump_short_description(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl << std::endl;
ss.str("");
dump_section(out, "Synopsis", show_hidden);
dump_synopsis(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl;
ss.str("");
dump_section(out, "Description", show_hidden);
dump_full_description(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl;
ss.str("");
dump_output_section(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl;
dump_section(out, "Options", show_hidden);
std::vector<std::string> str_opts;
size_t max_width(0);
for (CommandOptions::const_iterator it = _options.begin();
it != _options.end(); ++it)
{
if (show_hidden == false && it->second->is_hidden())
continue;
std::stringstream ss;
std::string short_opt("-");
short_opt.append(1, it->second->get_short_opt());
std::string long_opt("--");
long_opt.append(it->second->get_long_opt());
ss << " ";
ss << Boldify(short_opt) << ", " << Boldify(long_opt);
if (it->second->is_arg_expected())
ss << " " << it->second->get_arg_name();
str_opts.push_back(ss.str());
size_t real_size = Get_real_string_size(ss.str());
if (real_size > max_width)
max_width = real_size;
}
size_t i(0);
for (CommandOptions::const_iterator it = _options.begin();
it != _options.end(); ++it)
{
if (show_hidden == false && it->second->is_hidden())
continue;
indented_dump(str_opts.at(i), out, 0, max_width + 2, true, true);
std::stringstream ss;
ss << it->second->get_description();
if (it->second->is_arg_expected() &&
it->second->is_mandatory() == false &&
it->second->get_default_value().empty() == false)
ss << std::endl << "Default is '" <<
it->second->get_default_value() << "'.";
indented_dump(ss.str(), out, max_width + 2,
Get_tty_cols(), false, false);
out << std::endl;
++i;
}
out << std::endl;
dump_section(out, "Examples", show_hidden);
ss.str("");
dump_examples(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl;
if (_see_also.empty() == false)
{
dump_section(out, "See also", show_hidden);
ss.str("");
dump_see_also(ss, show_hidden);
indented_dump(ss.str(), out);
out << std::endl;
out << std::endl;
}
dump_section(out, "Author", show_hidden);
ss.str("");
ss << EXA_COPYRIGHT << std::endl;
indented_dump(ss.str(), out);
out << std::endl;
}
int main(int argc, char *argv[])
{
int fd;
int exit_code = EXIT_SUCCESS;
struct stat st;
unsigned int size;
uint8_t *buffer;
uint8_t *buffer_iterator;
struct actions_firmware_header header;
struct actions_firmware_section section;
unsigned int i = 0;
int ret = 1;
int err = 0;
int dump = 1;
const char *path_prefix;
if (argc != 3) {
usage(argv[0]);
exit(1);
}
path_prefix = argv[2];
err = mkdir(path_prefix, 0755);
if (err < 0) {
perror("mkdir");
exit_code = EXIT_FAILURE;
goto out;
}
fd = open(argv[1], O_RDONLY);
if (fd < 0) {
perror("open");
exit_code = EXIT_FAILURE;
goto out;
}
if (fstat(fd, &st) < 0) {
perror("fstat");
exit_code = EXIT_FAILURE;
goto out_close_fd;
}
size = st.st_size;
buffer = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (buffer == NULL) {
perror("mmap");
exit_code = EXIT_FAILURE;
goto out_close_fd;
}
if (size < ACTIONS_HEADER_DISK_SIZE) {
fprintf(stderr, "File cannot contain an Actions firmware header.\n");
exit_code = EXIT_FAILURE;
goto out_munmap;
}
/* iterate over a copy of the pointer */
buffer_iterator = buffer;
err = parse_header(&buffer_iterator, &header);
if (err) {
fprintf(stderr, "Cannot parse the header.\n");
exit_code = EXIT_FAILURE;
goto out_munmap;
}
print_header(&header);
while((err = parse_section(&buffer_iterator, §ion)) == 0) {
print_section(§ion);
i++;
if (strncmp((char *)section.name, "FIRM", 16) == 0) {
uint8_t *firm_buffer_iterator = buffer + section.start_address + 0x200;
struct actions_firmware_section firm_section;
struct actions_firmware_section prev_section = {
.start_address = section.start_address + 0x2000,
.length = 0,
};
while((err = parse_section(&firm_buffer_iterator, &firm_section)) == 0) {
/*
* unknown1 seems to be some form of checksum for
* firm sections, if a sections have the same
* checksum of the previous on they are not
* duplicated but refer to the same memory
* region, so do not increase che start
* address
*/
if (firm_section.unknown1 == prev_section.unknown1) {
firm_section.start_address = prev_section.start_address;
} else {
firm_section.start_address = prev_section.start_address + prev_section.length;
}
printf("\t");
print_section(&firm_section);
if (dump)
dump_section(path_prefix, "FIRM_", buffer, &firm_section);
prev_section = firm_section;
}
} else if (strncmp((char *)section.name, "LINUX", 16) == 0) {
continue;
}
if (dump)
dump_section(path_prefix, "", buffer, §ion);
}
