fpk/tools/fpack.c

#if !defined(_WIN32)
#define _FILE_OFFSET_BITS 64
#define _POSIX_C_SOURCE 200809L
#endif

#include "fpk.h"
#include <dirent.h>
#include <getopt.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#ifdef _WIN32
#include <windows.h>
#include <wchar.h>
#define PROGRAM_NAME "fpack.exe"
#define fpack_fseek64(f, off, whence) _fseeki64((f), (off), (whence))
#define fpack_ftell64(f) _ftelli64((f))
#else
#include <time.h>
#define PROGRAM_NAME "fpack"
#define fpack_fseek64(f, off, whence) fseeko((f), (off_t)(off), (whence))
#define fpack_ftell64(f) ftello((f))
#endif

#ifdef _WIN32
static wchar_t *utf8_to_wide(const char *s)
{
	int wlen = MultiByteToWideChar(CP_UTF8, 0, s, -1, NULL, 0);
	wchar_t *w;

	if (wlen <= 0)
		return NULL;
	w = malloc((size_t)wlen * sizeof(wchar_t));
	if (!w)
		return NULL;
	MultiByteToWideChar(CP_UTF8, 0, s, -1, w, wlen);
	return w;
}

static char *wide_to_utf8(const wchar_t *w)
{
	int len = WideCharToMultiByte(CP_UTF8, 0, w, -1, NULL, 0, NULL, NULL);
	char *s;

	if (len <= 0)
		return NULL;
	s = malloc((size_t)len);
	if (!s)
		return NULL;
	WideCharToMultiByte(CP_UTF8, 0, w, -1, s, len, NULL, NULL);
	return s;
}
#endif

static double now_seconds(void)
{
#ifdef _WIN32
	LARGE_INTEGER freq, count;

	QueryPerformanceFrequency(&freq);
	QueryPerformanceCounter(&count);
	return (double)count.QuadPart / (double)freq.QuadPart;
#else
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);
	return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9;
#endif
}

static void format_duration(double secs, char *buf, size_t bufsize)
{
	unsigned long total_ms = (unsigned long)(secs * 1000.0 + 0.5);
	unsigned long ms = total_ms % 1000;
	unsigned long total_s = total_ms / 1000;
	unsigned long s = total_s % 60;
	unsigned long total_m = total_s / 60;
	unsigned long m = total_m % 60;
	unsigned long total_h = total_m / 60;
	unsigned long h = total_h % 24;
	unsigned long d = total_h / 24;

	if (d > 0)
		sprintf(buf, "%lud %luh %lum %lus", d, h, m, s);
	else if (h > 0)
		sprintf(buf, "%luh %lum %lus", h, m, s);
	else if (m > 0)
		sprintf(buf, "%lum %lu.%03lus", m, s, ms);
	else
		sprintf(buf, "%lu.%03lus", s, ms);
	buf[bufsize - 1] = '\0';
}

#define FPACK_QUIET    (1u << 0)
#define FPACK_VERBOSE  (1u << 1)
#define FPACK_PROGRESS (1u << 2)

static unsigned char flags;
static uint64_t entry_count;
static uint64_t total_bytes;
static volatile sig_atomic_t interrupted;

static void handle_sigint(int sig)
{
	(void)sig;
	interrupted = 1;
}

static struct option long_opts[] = {
	{"output",   required_argument, NULL, 'o'},
	{"progress", no_argument,       NULL, 'p'},
	{"quiet",    no_argument,       NULL, 'q'},
	{"verbose",  no_argument,       NULL, 'v'},
	{"help",     no_argument,       NULL, 'h'},
	{NULL, 0, NULL, 0}
};

static char *dup_str(const char *s)
{
	size_t len = strlen(s) + 1;
	char *out = malloc(len);

	memcpy(out, s, len);
	return out;
}

static char *join_path(const char *dir, const char *name)
{
	size_t dir_len = strlen(dir);
	size_t name_len = strlen(name);
	char *out = malloc(dir_len + 1 + name_len + 1);

	memcpy(out, dir, dir_len);
	out[dir_len] = '/';
	memcpy(out + dir_len + 1, name, name_len);
	out[dir_len + 1 + name_len] = '\0';
	return out;
}

#ifdef _WIN32
#define IS_PATH_SEP(c) ((c) == '/' || (c) == '\\')
#else
#define IS_PATH_SEP(c) ((c) == '/')
#endif

static char *basename_dup(const char *path)
{
	size_t end = strlen(path);
	size_t start;
	char *out;

	while (end > 0 && IS_PATH_SEP(path[end - 1]))
		end--;

	start = end;
	while (start > 0 && !IS_PATH_SEP(path[start - 1]))
		start--;

	out = malloc(end - start + 1);
	memcpy(out, path + start, end - start);
	out[end - start] = '\0';
	return out;
}

static char *derive_output_name(const char *input_dir)
{
	char *base = basename_dup(input_dir);
	size_t len = strlen(base);
	char *out = malloc(len + 5);

	memcpy(out, base, len);
	memcpy(out + len, ".fpk", 5);
	free(base);
	return out;
}

static void normalize_path(char *s)
{
	for (; *s; s++) {
		if (*s == '\\')
			*s = '/';
	}
}

static void *read_file(const char *path, size_t *out_size)
{
	FILE *fp;
	int64_t len;
	void *buf;
#ifdef _WIN32
	wchar_t *wpath = utf8_to_wide(path);

	if (!wpath)
		return NULL;
	fp = _wfopen(wpath, L"rb");
	free(wpath);
#else
	fp = fopen(path, "rb");
#endif
	if (!fp)
		return NULL;

	if (fpack_fseek64(fp, 0, SEEK_END) != 0) {
		fclose(fp);
		return NULL;
	}
	len = fpack_ftell64(fp);
	if (len < 0 || fpack_fseek64(fp, 0, SEEK_SET) != 0) {
		fclose(fp);
		return NULL;
	}

	buf = malloc((size_t)len);
	if (!buf) {
		fclose(fp);
		return NULL;
	}

	if (fread(buf, 1, (size_t)len, fp) != (size_t)len) {
		free(buf);
		fclose(fp);
		return NULL;
	}

	fclose(fp);
	*out_size = (size_t)len;
	return buf;
}

static int add_file(struct fpk_writer *w, const char *path, size_t base_len)
{
	const char *rel_path = path + base_len;
	void *data;
	size_t size;
	char *norm;

	if (interrupted)
		return 0;

	while (*rel_path == '/')
		rel_path++;

	norm = dup_str(rel_path);
	normalize_path(norm);

	data = read_file(path, &size);
	if (!data) {
		fprintf(stderr, "fpack: cannot read: %s\n", path);
		free(norm);
		return 0;
	}

	if (fpk_writer_add(w, norm, data, size) != 0) {
		fprintf(stderr, "fpack: cannot add: %s\n", norm);
		free(data);
		free(norm);
		return 0;
	}

	entry_count++;
	total_bytes += size;

	if (flags & FPACK_VERBOSE)
		printf("  %s (%lu bytes)\n", norm, (unsigned long)size);

	if (flags & FPACK_PROGRESS) {
		printf("\rpacked %lu files (%lu bytes)",
		       (unsigned long)entry_count, (unsigned long)total_bytes);
		fflush(stdout);
	}

	free(data);
	free(norm);
	return 1;
}

#ifdef _WIN32
static int add_dir(struct fpk_writer *w, const char *dir, size_t base_len)
{
	char *pattern = join_path(dir, "*");
	wchar_t *wpattern = utf8_to_wide(pattern);
	WIN32_FIND_DATAW fd;
	HANDLE h;

	free(pattern);
	if (!wpattern) {
		fprintf(stderr, "fpack: cannot open directory: %s\n", dir);
		return 0;
	}

	h = FindFirstFileW(wpattern, &fd);
	free(wpattern);
	if (h == INVALID_HANDLE_VALUE) {
		fprintf(stderr, "fpack: cannot open directory: %s\n", dir);
		return 0;
	}

	do {
		char *name = wide_to_utf8(fd.cFileName);
		char *path;

		if (!name || name[0] == '.') {
			free(name);
			continue;
		}

		path = join_path(dir, name);
		free(name);

		if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
			if (!add_dir(w, path, base_len)) {
				free(path);
				FindClose(h);
				return 0;
			}
		} else if (!add_file(w, path, base_len)) {
			free(path);
			FindClose(h);
			return 0;
		}

		free(path);
	} while (FindNextFileW(h, &fd));

	FindClose(h);
	return 1;
}
#else
static int add_dir(struct fpk_writer *w, const char *dir, size_t base_len)
{
	DIR *d;
	struct dirent *ent;

	d = opendir(dir);
	if (!d) {
		fprintf(stderr, "fpack: cannot open directory: %s\n", dir);
		return 0;
	}

	while ((ent = readdir(d)) != NULL) {
		char *path;
		struct stat st;

		if (ent->d_name[0] == '.')
			continue;

		path = join_path(dir, ent->d_name);

		if (stat(path, &st) != 0) {
			fprintf(stderr, "fpack: cannot stat: %s\n", path);
			free(path);
			continue;
		}

		if (S_ISDIR(st.st_mode)) {
			if (!add_dir(w, path, base_len)) {
				free(path);
				closedir(d);
				return 0;
			}
		} else if (S_ISREG(st.st_mode)) {
			if (!add_file(w, path, base_len)) {
				free(path);
				closedir(d);
				return 0;
			}
		}

		free(path);
	}

	closedir(d);
	return 1;
}
#endif

static void usage(void)
{
	fprintf(stderr, "usage: %s [-o output.fpk] [-p] [-q] [-v] input_dir\n", PROGRAM_NAME);
	fprintf(stderr, "try '%s --help' for more information\n", PROGRAM_NAME);
	exit(1);
}

static void help(void)
{
	printf("usage: %s [options] input_dir\n", PROGRAM_NAME);
	printf("\n");
	printf("Pack a directory tree into an fpk archive.\n");
	printf("\n");
	printf("options:\n");
	printf("  -o, --output=FILE  write the archive to FILE instead of the derived name\n");
	printf("  -p, --progress     print packing progress\n");
	printf("  -q, --quiet        suppress the final summary line\n");
	printf("  -v, --verbose      print each packed entry\n");
	printf("  -h, --help         show this help and exit\n");
	exit(0);
}

int main(int argc, char **argv)
{
	const char *output_arg = NULL;
	const char *input_dir;
	char *output;
	size_t base_len;
	struct fpk_writer *w;
	int c;
	double start_time;

	while ((c = getopt_long(argc, argv, "o:pqvh", long_opts, NULL)) != -1) {
		switch (c) {
		case 'o':
			output_arg = optarg;
			break;
		case 'p':
			flags |= FPACK_PROGRESS;
			break;
		case 'q':
			flags |= FPACK_QUIET;
			break;
		case 'v':
			flags |= FPACK_VERBOSE;
			break;
		case 'h':
			help();
			break;
		default:
			usage();
		}
	}

	if (optind != argc - 1)
		usage();

	input_dir = argv[optind];
	output = output_arg ? dup_str(output_arg) : derive_output_name(input_dir);

	start_time = now_seconds();

	base_len = strlen(input_dir);
	while (base_len > 0 && IS_PATH_SEP(input_dir[base_len - 1]))
		base_len--;

	w = fpk_writer_open(output);
	if (!w) {
		fprintf(stderr, "fpack: cannot create: %s\n", output);
		free(output);
		return 1;
	}

	signal(SIGINT, handle_sigint);

	if (!add_dir(w, input_dir, base_len)) {
		fpk_writer_close(w);
		if (interrupted) {
			remove(output);
			fprintf(stderr, "\nfpack: interrupted, removed incomplete archive: %s\n", output);
			free(output);
			return 130;
		}
		free(output);
		return 1;
	}

	if (entry_count == 0) {
		fprintf(stderr, "fpack: no files found in: %s\n", input_dir);
		fpk_writer_close(w);
		free(output);
		return 1;
	}

	if (fpk_writer_finalize(w) != 0) {
		fprintf(stderr, "fpack: failed to finalize: %s\n", output);
		fpk_writer_close(w);
		free(output);
		return 1;
	}

	fpk_writer_close(w);

	if (flags & FPACK_PROGRESS)
		printf("\n");

	if (!(flags & FPACK_QUIET)) {
		char dur[64];

		format_duration(now_seconds() - start_time, dur, sizeof(dur));
		printf("wrote: %s (%lu entries) in %s\n", output,
		       (unsigned long)entry_count, dur);
	}

	free(output);
	return 0;
}