322 lines
8.9 KiB
C
322 lines
8.9 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2008 by Maurus Cuelenaere
|
|
*
|
|
* 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 software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
* KIND, either express or implied.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <stdbool.h>
|
|
#include <dirent.h>
|
|
|
|
#define VERSION "0.2"
|
|
|
|
static unsigned char* int2le(unsigned int val)
|
|
{
|
|
static unsigned char addr[4];
|
|
addr[0] = val & 0xff;
|
|
addr[1] = (val >> 8) & 0xff;
|
|
addr[2] = (val >> 16) & 0xff;
|
|
addr[3] = (val >> 24) & 0xff;
|
|
return addr;
|
|
}
|
|
|
|
static unsigned int le2int(unsigned char* buf)
|
|
{
|
|
unsigned int res = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
|
|
|
|
return res;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
#define PATH_SEPARATOR "\\"
|
|
#else
|
|
#define PATH_SEPARATOR "/"
|
|
#endif
|
|
|
|
#ifndef _WIN32
|
|
|
|
#define MIN(a, b) (a > b ? b : a)
|
|
static char* replace(char* str)
|
|
{
|
|
static char tmp[255];
|
|
memcpy(tmp, str, MIN(strlen(str), 255));
|
|
char *ptr = tmp;
|
|
while(*ptr != 0)
|
|
{
|
|
if(*ptr == 0x2F) /* /*/
|
|
*ptr = 0x5C; /* \ */
|
|
ptr++;
|
|
}
|
|
return tmp;
|
|
}
|
|
#endif
|
|
|
|
static bool is_dir(const char* name1, const char* name2)
|
|
{
|
|
char *name;
|
|
DIR *directory;
|
|
name = (char*)malloc(strlen(name1)+strlen(name2)+1);
|
|
strcpy(name, name1);
|
|
strcat(name, name2);
|
|
directory = opendir(name);
|
|
free(name);
|
|
if(directory)
|
|
{
|
|
closedir(directory);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
unsigned int _filesize(FILE* fd)
|
|
{
|
|
unsigned int tmp, oldpos;
|
|
oldpos = ftell(fd);
|
|
fseek(fd, 0, SEEK_END);
|
|
tmp = ftell(fd);
|
|
fseek(fd, oldpos, SEEK_SET);
|
|
return tmp;
|
|
}
|
|
#define WRITE(x, len) if(fwrite(x, len, 1, outfile) != 1) \
|
|
{ \
|
|
closedir(indir_handle); \
|
|
if(filesize > 0) \
|
|
free(buffer); \
|
|
fprintf(stderr, "[ERR] Error writing to file\n"); \
|
|
return; \
|
|
}
|
|
static void merge_hxf(const char* indir, FILE* outfile, const char* add)
|
|
{
|
|
DIR *indir_handle;
|
|
struct dirent *dirs;
|
|
char dir[255];
|
|
strcpy(dir, indir);
|
|
strcat(dir, add);
|
|
|
|
if((indir_handle = opendir(dir)) == NULL)
|
|
{
|
|
fprintf(stderr, "[ERR] Error opening dir %s\n", indir);
|
|
return;
|
|
}
|
|
|
|
while((dirs = readdir(indir_handle)) != NULL)
|
|
{
|
|
if(strcmp(dirs->d_name, "..") != 0 &&
|
|
strcmp(dirs->d_name, ".") != 0)
|
|
{
|
|
fprintf(stderr, "[INFO] %s\%s\n", add, dirs->d_name);
|
|
if(is_dir(dir, dirs->d_name))
|
|
{
|
|
char dir2[255];
|
|
strcpy(dir2, add);
|
|
strcat(dir2, dirs->d_name);
|
|
strcat(dir2, PATH_SEPARATOR);
|
|
merge_hxf(indir, outfile, dir2);
|
|
}
|
|
else
|
|
{
|
|
FILE *filehandle;
|
|
unsigned char *buffer;
|
|
char file[255];
|
|
unsigned int filesize;
|
|
strcpy(file, dir);
|
|
strcat(file, dirs->d_name);
|
|
if((filehandle = fopen(file, "rb")) == NULL)
|
|
{
|
|
fprintf(stderr, "[ERR] Cannot open %s\n", file);
|
|
closedir(indir_handle);
|
|
return;
|
|
}
|
|
filesize = _filesize(filehandle);
|
|
if(filesize > 0)
|
|
{
|
|
buffer = (unsigned char*)malloc(filesize);
|
|
if(buffer == NULL)
|
|
{
|
|
fclose(filehandle);
|
|
closedir(indir_handle);
|
|
fprintf(stderr, "[ERR] Cannot allocate memory\n");
|
|
return;
|
|
}
|
|
if(fread(buffer, filesize, 1, filehandle) != 1)
|
|
{
|
|
fclose(filehandle);
|
|
closedir(indir_handle);
|
|
free(buffer);
|
|
fprintf(stderr, "[ERR] Cannot read from %s%s%s\n", add, PATH_SEPARATOR, dirs->d_name);
|
|
return;
|
|
}
|
|
}
|
|
fclose(filehandle);
|
|
|
|
if(strlen(add)>0)
|
|
{
|
|
#ifdef _DIRENT_HAVE_D_NAMLEN
|
|
WRITE(int2le(dirs->d_namlen+strlen(add)), 4);
|
|
#else
|
|
WRITE(int2le(strlen(dirs->d_name)+strlen(add)), 4);
|
|
#endif
|
|
#ifndef _WIN32
|
|
WRITE(replace((char*)add), strlen(add)-1);
|
|
#else
|
|
WRITE(add, strlen(add)-1);
|
|
#endif
|
|
WRITE(PATH_SEPARATOR, 1);
|
|
#ifdef _DIRENT_HAVE_D_NAMLEN
|
|
WRITE(dirs->d_name, dirs->d_namlen);
|
|
#else
|
|
WRITE(dirs->d_name, strlen(dirs->d_name));
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
#ifdef _DIRENT_HAVE_D_NAMLEN
|
|
WRITE(int2le(dirs->d_namlen), 4);
|
|
WRITE(dirs->d_name, dirs->d_namlen);
|
|
#else
|
|
WRITE(int2le(strlen(dirs->d_name)), 4);
|
|
WRITE(dirs->d_name, strlen(dirs->d_name));
|
|
#endif
|
|
}
|
|
WRITE(int2le(filesize), 4);
|
|
if(filesize>0)
|
|
{
|
|
WRITE(buffer, filesize);
|
|
free(buffer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir(indir_handle);
|
|
}
|
|
|
|
static void print_usage(void)
|
|
{
|
|
#ifdef _WIN32
|
|
fprintf(stderr, "Usage: hxfmerge.exe [INPUT_DIR] [FW]\n\n");
|
|
fprintf(stderr, "Example: hxfmerge.exe VX747_extracted\\ VX747.HXF\n\n");
|
|
#else
|
|
fprintf(stderr, "Usage: HXFmerge [INPUT_DIR] [FW]\n\n");
|
|
fprintf(stderr, "Example: HXFmerge VX747_extracted/ VX747.HXF\n\n");
|
|
#endif
|
|
}
|
|
|
|
static int checksum(FILE *file)
|
|
{
|
|
int oldpos = ftell(file);
|
|
int ret=0, i, filesize = _filesize(file)-0x40;
|
|
unsigned char *buf;
|
|
|
|
buf = (unsigned char*)malloc(filesize);
|
|
|
|
if(buf == NULL)
|
|
{
|
|
fseek(file, oldpos, SEEK_SET);
|
|
fprintf(stderr, "[ERR] Error while allocating memory\n");
|
|
return 0;
|
|
}
|
|
|
|
fseek(file, 0x40, SEEK_SET);
|
|
if(fread(buf, filesize, 1, file) != 1)
|
|
{
|
|
free(buf);
|
|
fseek(file, oldpos, SEEK_SET);
|
|
fprintf(stderr, "[ERR] Error while reading from file\n");
|
|
return 0;
|
|
}
|
|
|
|
fprintf(stderr, "[INFO] Computing checksum...");
|
|
|
|
for(i = 0; i < filesize; i+=4)
|
|
ret += le2int(&buf[i]);
|
|
|
|
free(buf);
|
|
fseek(file, oldpos, SEEK_SET);
|
|
|
|
fprintf(stderr, " Done!\n");
|
|
return ret;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
FILE *outfile;
|
|
|
|
fprintf(stderr, "HXFmerge v" VERSION " - (C) 2008 Maurus Cuelenaere\n");
|
|
fprintf(stderr, "This is free software; see the source for copying conditions. There is NO\n");
|
|
fprintf(stderr, "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
|
|
|
|
if(argc != 3)
|
|
{
|
|
print_usage();
|
|
return 1;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
if(strcmp((char*)(argv[1]+strlen(argv[1])-1), "\\") != 0)
|
|
{
|
|
fprintf(stderr, "[ERR] Input path must end with a \\\n");
|
|
#else
|
|
if(strcmp((char*)(argv[1]+strlen(argv[1])-1), "/") != 0)
|
|
{
|
|
fprintf(stderr, "[ERR] Input path must end with a /\n");
|
|
#endif
|
|
return 2;
|
|
}
|
|
|
|
if((outfile = fopen(argv[2], "wb+")) == NULL)
|
|
{
|
|
fprintf(stderr, "[ERR] Cannot open %s\n", argv[2]);
|
|
return 3;
|
|
}
|
|
|
|
fseek(outfile, 0x40, SEEK_SET);
|
|
|
|
merge_hxf(argv[1], outfile, "");
|
|
|
|
fflush(outfile);
|
|
|
|
fprintf(stderr, "[INFO] Filling header...\n");
|
|
|
|
#undef WRITE
|
|
#define WRITE(x, len) if(fwrite(x, len, 1, outfile) != 1) \
|
|
{ \
|
|
fprintf(stderr, "[ERR] Cannot write to %s\n", argv[1]); \
|
|
fclose(outfile); \
|
|
return 4; \
|
|
}
|
|
fflush(outfile);
|
|
fseek(outfile, 0, SEEK_SET);
|
|
WRITE("WADF0100200804111437", 20);
|
|
WRITE(int2le(_filesize(outfile)), 4);
|
|
WRITE(int2le(checksum(outfile)), 4);
|
|
WRITE(int2le(0), 4);
|
|
WRITE("Chinachip PMP firmware V1.0\0\0\0\0\0", 32);
|
|
fclose(outfile);
|
|
|
|
fprintf(stderr, "[INFO] Done!\n");
|
|
|
|
return 0;
|
|
}
|