/**
* Efficient tar+bzip2 extractor for in-game use
* Copyright (C) 2004 Andrew Reading
* Copyright (C) 2007, 2008, 2014, 2018 Sylvain Beucler
* This file is part of GNU FreeDink
* GNU FreeDink 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 3 of the
* License, or (at your option) any later version.
* GNU FreeDink 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.
* You should have received a copy of the GNU General Public License
* along with this program. If not, see
* .
*/
#ifdef HAVE_CONFIG_H
#include
#else
#define _(s) s
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
struct TarHeader {
char Name[100+1]; // 100
char Mode[8+1]; // 108
char Uid[8+1]; // 116
char Gid[8+1]; // 124
char Size[12+1]; // 136
char Mtime[12+1]; // 148
char Chksum[8+1]; // 156
char Linkflag[1+1]; // 157
char Linkname[100+1]; // 257
char Magic[8+1]; // 265
char Uname[32+1]; // 297
char Gname[32+1]; // 329
char Devmajor[8+1]; // 337
char Devminor[8+1]; // 345
char Padding[167+1]; // 512
};
#define TAR_HEADER_SIZE 512
int mkdir_rec(char* path) {
int ret;
mode_t mode = 00755;
ret = mkdir(path, mode);
if (ret == 0 || errno == EEXIST) {
return 0;
} else {
char* dir = strdup(path);
dirname(dir);
ret = mkdir_rec(dir);
free(dir);
if (ret < 0) {
return ret;
}
if ((ret = mkdir(path, mode)) < 0) {
perror("mkdir");
return ret;
}
return 0;
}
}
int DirExists(char* path) {
struct stat st;
return (stat(path, &st) == 0 && S_ISDIR(st.st_mode));
}
void print_bzerror(BZFILE* bzin, int bzerror) {
printf("%s\n", BZ2_bzerror(bzin, &bzerror));
if (bzerror == BZ_OK || bzerror == BZ_STREAM_END) {
// Success
} else if (bzerror == BZ_PARAM_ERROR) {
printf(_("Invalid .dmod file specified."));
} else if (bzerror == BZ_SEQUENCE_ERROR) {
printf(_("Critical program function error: opened for write."));
} else if (bzerror == BZ_IO_ERROR) {
printf(_("Could not read .dmod file.") );
} else if (bzerror == BZ_UNEXPECTED_EOF) {
printf(_("Incomplete .dmod file. Please download it again.") );
} else if (bzerror == BZ_DATA_ERROR) {
printf(_("The .dmod file is corrupted. Please download it again."));
} else if (bzerror == BZ_DATA_ERROR_MAGIC) {
printf(_("The file is not a valid .dmod file."));
} else if (bzerror == BZ_MEM_ERROR) {
printf(_("Out of memory error."));
} else {
printf(_("An unhandled error occurred."));
}
printf("\n");
}
/**
* Read all tar headers from a flux, so it can work if reading file
* with BZip2 directly (only the 'read' operation is available).
*/
int TarFillHeaderFromStream(BZFILE* bzin, struct TarHeader* tarHeader)
{
memset(tarHeader, 0, sizeof(*tarHeader));
// Read the data. Don't load the whole header to a struct, you
// never know what the memory alignment will be, especially in
// these 32->64bits days
int bzerror;
BZ2_bzRead(&bzerror, bzin, tarHeader->Name, 100); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Mode, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Uid, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Gid, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Size, 12); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Mtime, 12); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Chksum, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Linkflag, 1); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Linkname, 100); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Magic, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Uname, 32); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Gname, 32); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Devmajor, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Devminor, 8); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
BZ2_bzRead(&bzerror, bzin, tarHeader->Padding, 167); if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
return bzerror;
}
unsigned int TarComputeChecksum(struct TarHeader* tarHeader) {
unsigned int sum = 0;
char blankChecksum[8+1] = " ";
for (int i = 0; i < 100; i++) { sum += tarHeader->Name[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Mode[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Uid[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Gid[i]; }
for (int i = 0; i < 12; i++) { sum += tarHeader->Size[i]; }
for (int i = 0; i < 12; i++) { sum += tarHeader->Mtime[i]; }
//for (int i = 0; i < 8; i++) { sum += tarHeader->Chksum[i]; }
for (int i = 0; i < 8; i++) { sum += blankChecksum[i]; }
for (int i = 0; i < 1; i++) { sum += tarHeader->Linkflag[i]; }
for (int i = 0; i < 100; i++) { sum += tarHeader->Linkname[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Magic[i]; }
for (int i = 0; i < 32; i++) { sum += tarHeader->Uname[i]; }
for (int i = 0; i < 32; i++) { sum += tarHeader->Gname[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Devmajor[i]; }
for (int i = 0; i < 8; i++) { sum += tarHeader->Devminor[i]; }
for (int i = 0; i < 167; i++) { sum += tarHeader->Padding[i]; }
return sum;
}
void GetFirstDir(const char* path, char* dmodDir) {
char* firstDir = "";
char* previousDir = "";
char* checkPath = malloc(strlen(path)+strlen("dummy")+1);
strcpy(checkPath, path);
// tokenizer never returns empty strings + distinguish dir// and a/$
char last = path[strlen(path)-1];
if (last == '\\' || last == '/')
strcat(checkPath, "dummy");
char *str, *curDir, *saveptr;
for (str = checkPath; ; str = NULL) {
curDir = strtok_r(str, "/\\", &saveptr);
if (curDir == NULL)
break;
if (strcmp(curDir, ".") == 0)
continue;
if (strcmp(previousDir, "") != 0) {
firstDir = previousDir;
break;
}
previousDir = curDir;
}
strcpy(dmodDir, firstDir);
free(checkPath);
}
int TarIsPathInsecure(char* path, char* prefix) {
if (path[0] == '/' || path[0] == '\\')
return 1;
{
char *str, *token, *saveptr;
str = strdup(path);
token = strtok_r(str, "/\\", &saveptr);
if (strcmp(token, prefix) != 0) {
free(str);
return 1;
}
free(str);
}
{
char *str, *token, *saveptr;
for (str = path; ; str = NULL) {
token = strtok_r(str, "/\\", &saveptr);
if (token == NULL)
break;
if (strcmp(token, "..") == 0)
return 1;
}
}
return 0;
}
int DmodExtract(FILE* dmodFile, char* destDir, char** extractedDmodDir) {
// Get the file size
unsigned long dmodFileCompressedSize;
if (fseek(dmodFile, 0, SEEK_END) < 0) perror("fseek");
dmodFileCompressedSize = ftell(dmodFile);
if (fseek(dmodFile, 0, SEEK_SET) < 0) perror("fseek");
int bzerror = BZ_OK;
BZFILE* bzin = BZ2_bzReadOpen(&bzerror, dmodFile, 0, 0, 0, 0);
if (bzerror != BZ_OK) {
print_bzerror(bzin, bzerror);
printf(_("Error: Invalid .dmod file selected!"));
printf("\n");
return -1;
}
struct TarHeader tarHeader;
unsigned int total_read = 0;
int lastPercent = 0;
char dmodDir[100+1] = {};
// Keep getting chunks of the file
while (1) {
unsigned char* buf;
int nbReadUncompressed;
int ret = TarFillHeaderFromStream(bzin, &tarHeader);
total_read += 512;
if (ret < 0) {
break;
}
// Define dmodDir which needs to be consistent in all the archive
if (strcmp(dmodDir, "") == 0) {
GetFirstDir(tarHeader.Name, dmodDir);
if (strcmp(dmodDir, "") == 0 || strcmp(dmodDir, "..") == 0)
{
printf(_("Error: empty D-Mod directory. Stopping.\n"));
return 1;
}
char* dmodFullPath = malloc(strlen(destDir)+1+strlen(dmodDir)+1);
sprintf(dmodFullPath, "%s/%s", destDir, dmodDir);
if (DirExists(dmodFullPath)) {
printf(_("Error: directory '%s' already exists. Stopping.\n"), dmodDir);
free(dmodFullPath);
return 1;
}
free(dmodFullPath);
printf("D-Mod dir: %s\n", dmodDir);
}
// Bug fix for phantom files that aren't really files...
// This is due to a bug in DFArc1.5 with empty files
if (strcmp(tarHeader.Name, "\xFF") == 0) {
continue;
}
// Tar files (except for a design bug in DFArc1.5) have a
// multitude of NULL characters at the end to round up to the
// 10K mark. If the header is blank, we don't have any more
// data.
if (strcmp(tarHeader.Name, "") == 0) {
break;
}
// TODO: ISO-8869-1 -> UTF-8?
// Size
unsigned long fileSize = 0;
sscanf((const char*)&tarHeader.Size, "%lo", &fileSize);
// Extract
char last = tarHeader.Name[strlen(tarHeader.Name)-1];
if (last == '\\' || last == '/') {
// directory, skip and let mkdir_rec do its job
} else {
unsigned int checksum = 0;
unsigned int expected = TarComputeChecksum(&tarHeader);
sscanf((const char*)&tarHeader.Chksum, "%o", &checksum);
if (checksum != expected) {
printf("Incorrect checksum, but proceeding anyway: found 0%o, expected 0%o\n", checksum, expected);
}
char* checkName = strdup(tarHeader.Name);
if (TarIsPathInsecure(checkName, dmodDir)) {
printf("Insecure path, stopping: %s\n", tarHeader.Name);
free(checkName);
return 1;
}
free(checkName);
char* destFullPath = malloc(strlen(destDir)+1+strlen(tarHeader.Name)+1);
sprintf(destFullPath, "%s/%s", destDir, tarHeader.Name);
//printf("* Extracting to: %s\n", destFullPath);
char* dir = strdup(destFullPath);
dirname(dir);
int ret = mkdir_rec(dir);
if (ret < 0) printf("Error creating directory %s\n", dir);
free(dir);
if (ret < 0) {
free(destFullPath);
break;
}
{
// bzip2 -9 -> 900kiB blocks - randomly using 4MiB buf, we
// might get better precision with low-level BZ2 API
char buf[4*1024*1024];
FILE* out = fopen(destFullPath, "wb");
if (out == NULL) {
perror("fopen");
break;
}
unsigned long nbRemaining = fileSize;
while (nbRemaining > 0) {
nbReadUncompressed = (nbRemaining > sizeof(buf)) ? sizeof(buf) : nbRemaining;
nbReadUncompressed = BZ2_bzRead(&bzerror, bzin, buf, nbReadUncompressed);
if (bzerror != BZ_OK && bzerror != BZ_STREAM_END) { print_bzerror(bzin, bzerror); return 1; };
fwrite(buf, nbReadUncompressed, 1, out);
nbRemaining -= nbReadUncompressed;
{
unsigned long pos = ftell(dmodFile);
double percent = 100.0 * pos / dmodFileCompressedSize;
if ((int)percent != lastPercent)
printf("progress: %lu %lu %.02f%%\n", pos, dmodFileCompressedSize, percent);
lastPercent = (int)percent;
}
}
if (bzerror == BZ_STREAM_END) {
// old .mod without end-of-archive record nor padding, no error output
break;
}
fclose(out);
}
free(destFullPath);
total_read += fileSize;
}
// Move to the beginning of the next header
char padding[512];
int padding_size = (512 - (total_read % 512)) % 512;
BZ2_bzRead(&bzerror, bzin, padding, padding_size);
if (bzerror != BZ_OK) { print_bzerror(bzin, bzerror); return 1; }
total_read += padding_size;
}
BZ2_bzReadClose(&bzerror, bzin);
if (extractedDmodDir != NULL) {
*extractedDmodDir = strdup(dmodDir);
}
return 0;
}
int emDmodExtract(char* filename, char* destdir, char** extractedDmodDir) {
// printf("emDmodExtract(%s, %s)\n", filename, destdir);
FILE* in = fopen(filename, "rb");
if (in == NULL) {
perror("fopen");
printf("Cannot open %s\n", filename);
return 1;
}
return DmodExtract(in, destdir, extractedDmodDir);
}
#ifdef TEST
int main(int argc, char* argv[]) {
{
char buf[100+1];
assert((strcpy(buf, "../"), TarIsPathInsecure(buf, "..") == 1));
assert((strcpy(buf, "/../"), TarIsPathInsecure(buf, "") == 1));
assert((strcpy(buf, "/../"), TarIsPathInsecure(buf, "..") == 1));
assert((strcpy(buf, ".."), TarIsPathInsecure(buf, "..") == 1));
assert((strcpy(buf, "/.."), TarIsPathInsecure(buf, "") == 1));
assert((strcpy(buf, "/.."), TarIsPathInsecure(buf, "..") == 1));
assert((strcpy(buf, "path/.."), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "path/subpath/.."), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "path/../subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "../path/subpath"), TarIsPathInsecure(buf, "..") == 1));
assert((strcpy(buf, "../path/subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "/path/subpath"), TarIsPathInsecure(buf, "") == 1));
assert((strcpy(buf, "/path/subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "\\path/subpath"), TarIsPathInsecure(buf, "") == 1));
assert((strcpy(buf, "\\path/subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "path\\..\\subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "path"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path/"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path\\"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path/subpath"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path\\subpath"), TarIsPathInsecure(buf, "path") == 0));
assert((strcpy(buf, "path2\\subpath"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "dink.exe"), TarIsPathInsecure(buf, "path") == 1));
assert((strcpy(buf, "dink.exe"), TarIsPathInsecure(buf, "path") == 1));
}
return emDmodExtract(argv[1], "/tmp/testdmod", NULL);
}
#endif