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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#ifdef _WIN32
#define PROGRAM_NAME "fpack.exe"
#define fpack_fseek64(f, off, whence) _fseeki64((f), (off), (whence))
#define fpack_ftell64(f) _ftelli64((f))
#else
#define PROGRAM_NAME "fpack"
#define fpack_fseek64(f, off, whence) fseeko((f), (off_t)(off), (whence))
#define fpack_ftell64(f) ftello((f))
#endif

#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 struct option long_opts[] = {
	{"output",   required_argument, NULL, 'o'},
	{"progress", no_argument,       NULL, 'p'},
	{"quiet",    no_argument,       NULL, 'q'},
	{"verbose",  no_argument,       NULL, 'v'},
	{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;
}

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

	while (end > 0 && path[end - 1] == '/')
		end--;

	start = end;
	while (start > 0 && 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;

	fp = fopen(path, "rb");
	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_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)) {
			const char *rel_path = path + base_len;
			void *data;
			size_t size;
			char *norm;

			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);
				free(path);
				closedir(d);
				return 0;
			}

			if (fpk_writer_add(w, norm, data, size) != 0) {
				fprintf(stderr, "fpack: cannot add: %s\n", norm);
				free(data);
				free(norm);
				free(path);
				closedir(d);
				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);
		}

		free(path);
	}

	closedir(d);
	return 1;
}

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

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;

	while ((c = getopt_long(argc, argv, "o:pqv", 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;
		default:
			usage();
		}
	}

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

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

	base_len = strlen(input_dir);
	while (base_len > 0 && 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;
	}

	if (!add_dir(w, input_dir, base_len)) {
		fpk_writer_close(w);
		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))
		printf("wrote: %s (%lu entries)\n", output, (unsigned long)entry_count);

	free(output);
	return 0;
}