| /*************************************************************************** |
| * __________ __ ___. |
| * 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; |
| } |