X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=pak.c;h=653a4630a133905d62c99845c9902e15dddf3566;hp=29e028c52e55cc4e7e632828b8800def609922f8;hb=69b55ccc03b56af1f6c05eb45866ab198307487f;hpb=945aba6e10dfec4ec987e918dcab27ed4a84138f diff --git a/pak.c b/pak.c index 29e028c..653a463 100644 --- a/pak.c +++ b/pak.c @@ -1,6 +1,6 @@ /* * Copyright (C) 2013 - * Dale Weiler + * Dale Weiler * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in @@ -20,15 +20,13 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#include -#include #include "gmqcc.h" /* * The PAK format uses a FOURCC concept for storing the magic ident within * the header as a uint32_t. - */ -#define PAK_FOURCC ((uint32_t)(('P' << 24) | ('A' << 16) | ('C' << 8) | 'K')) + */ +#define PAK_FOURCC ((uint32_t)(('P' | ('A' << 8) | ('C' << 16) | ('K' << 24)))) typedef struct { uint32_t magic; /* "PACK" */ @@ -38,7 +36,7 @@ typedef struct { * best to store the directories at the end of the file opposed * to the front, since it allows easy insertion without having * to load the entire file into memory again. - */ + */ uint32_t diroff; uint32_t dirlen; } pak_header_t; @@ -49,7 +47,7 @@ typedef struct { * describes a file (with directories/nested ones too in it's * file name). Hence it can be a file, file with directory, or * file with directories. - */ + */ typedef struct { char name[56]; uint32_t pos; @@ -60,7 +58,7 @@ typedef struct { * Used to get the next token from a string, where the * strings themselfs are seperated by chracters from * `sep`. This is essentially strsep. - */ + */ static char *pak_tree_sep(char **str, const char *sep) { char *beg = *str; char *end; @@ -96,16 +94,15 @@ static void pak_tree_build(const char *entry) { directory = (char *)mem_a(56); memset(pathsplit, 0, 56); - memset(directory, 0, 56); - strncpy(directory, entry, 56); + util_strncpy(directory, entry, 56); for (itr = 0; (token = pak_tree_sep(&directory, "/")) != NULL; itr++) { elements[itr] = token; } for (jtr = 0; jtr < itr - 1; jtr++) { - strcat(pathsplit, elements[jtr]); - strcat(pathsplit, "/"); + util_strcat(pathsplit, elements[jtr]); + util_strcat(pathsplit, "/"); if (fs_dir_make(pathsplit)) { mem_d(pathsplit); @@ -161,13 +158,13 @@ static pak_file_t *pak_open_read(const char *file) { /* * Time to read in the directory handles and prepare the directories * vector. We're going to be reading some the file inwards soon. - */ + */ fs_file_seek(pak->handle, pak->header.diroff, SEEK_SET); /* * Read in all directories from the PAK file. These are considered * to be the "file entries". - */ + */ for (itr = 0; itr < pak->header.dirlen / 64; itr++) { pak_directory_t dir; fs_file_read (&dir, sizeof(pak_directory_t), 1, pak->handle); @@ -187,16 +184,17 @@ static pak_file_t *pak_open_write(const char *file) { /* * Generate the required directory structure / tree for * writing this PAK file too. - */ + */ pak_tree_build(file); if (!(pak->handle = fs_file_open(file, "wb"))) { /* * The directory tree that was created, needs to be * removed entierly if we failed to open a file. - */ + */ /* TODO backup directory clean */ + mem_d(pak); return NULL; } @@ -210,6 +208,9 @@ static pak_file_t *pak_open_write(const char *file) { pak->insert = true; pak->header.magic = PAK_FOURCC; + /* on BE systems we need to swap the byte order of the FOURCC */ + util_endianswap(&pak->header.magic, 1, sizeof(uint32_t)); + /* * We need to write out the header since files will be wrote out to * this even with directory entries, and that not wrote. The header @@ -238,13 +239,13 @@ bool pak_exists(pak_file_t *pak, const char *file, pak_directory_t **dir) { if (!pak || !file) return false; - + for (itr = 0; itr < vec_size(pak->directories); itr++) { if (!strcmp(pak->directories[itr].name, file)) { /* * Store back a pointer to the directory that matches * the request if requested (NULL is not allowed). - */ + */ if (dir) { *dir = &(pak->directories[itr]); } @@ -257,10 +258,11 @@ bool pak_exists(pak_file_t *pak, const char *file, pak_directory_t **dir) { /* * Extraction abilities. These work as you expect them to. - */ -bool pak_extract_one(pak_file_t *pak, const char *file) { - pak_directory_t *dir = NULL; - unsigned char *dat = NULL; + */ +bool pak_extract_one(pak_file_t *pak, const char *file, const char *outdir) { + pak_directory_t *dir = NULL; + unsigned char *dat = NULL; + char *local = NULL; FILE *out; if (!pak_exists(pak, file, &dir)) { @@ -274,18 +276,23 @@ bool pak_extract_one(pak_file_t *pak, const char *file) { /* * Generate the directory structure / tree that will be required * to store the extracted file. - */ + */ pak_tree_build(file); + /* TODO portable path seperators */ + util_asprintf(&local, "%s/%s", outdir, file); + /* * Now create the file, if this operation fails. Then abort * It shouldn't fail though. - */ - if (!(out = fs_file_open(file, "wb"))) { + */ + if (!(out = fs_file_open(local, "wb"))) { mem_d(dat); return false; } + /* free memory for directory string */ + mem_d(local); /* read */ fs_file_seek (pak->handle, dir->pos, SEEK_SET); @@ -309,11 +316,8 @@ bool pak_extract_all(pak_file_t *pak, const char *dir) { if (!fs_dir_make(dir)) return false; - if (fs_dir_change(dir)) - return false; - for (itr = 0; itr < vec_size(pak->directories); itr++) { - if (!pak_extract_one(pak, pak->directories[itr].name)) + if (!pak_extract_one(pak, pak->directories[itr].name, dir)) return false; } @@ -332,8 +336,8 @@ bool pak_insert_one(pak_file_t *pak, const char *file) { /* * We don't allow insertion on files that already exist within the * pak file. Weird shit can happen if we allow that ;). We also - * don't allow insertion if the pak isn't opened in write mode. - */ + * don't allow insertion if the pak isn't opened in write mode. + */ if (!pak || !file || !pak->insert || pak_exists(pak, file, NULL)) return false; @@ -354,18 +358,18 @@ bool pak_insert_one(pak_file_t *pak, const char *file) { /* * We're limited to 56 bytes for a file name string, that INCLUDES * the directory and '/' seperators. - */ + */ if (strlen(file) >= 56) { fs_file_close(fp); return false; } - strcpy(dir.name, file); + util_strncpy(dir.name, file, strlen(file)); /* * Allocate some memory for loading in the data that will be * redirected into the PAK file. - */ + */ if (!(dat = (unsigned char *)mem_a(dir.len))) { fs_file_close(fp); return false; @@ -387,7 +391,7 @@ bool pak_insert_one(pak_file_t *pak, const char *file) { /* * Like pak_insert_one, except this collects files in all directories * from a root directory, and inserts them all. - */ + */ bool pak_insert_all(pak_file_t *pak, const char *dir) { DIR *dp; struct dirent *dirp; @@ -418,12 +422,12 @@ bool pak_close(pak_file_t *pak) { /* * In insert mode we need to patch the header, and write * our directory entries at the end of the file. - */ + */ if (pak->insert) { pak->header.dirlen = vec_size(pak->directories) * 64; pak->header.diroff = ftell(pak->handle); - /* patch header */ + /* patch header */ fs_file_seek (pak->handle, 0, SEEK_SET); fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle); @@ -441,3 +445,137 @@ bool pak_close(pak_file_t *pak) { return true; } + +/* + * Fancy GCC-like LONG parsing allows things like --opt=param with + * assignment operator. This is used for redirecting stdout/stderr + * console to specific files of your choice. + */ +static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) { + int argc = *argc_; + char **argv = *argv_; + + size_t len = strlen(optname); + + if (strncmp(argv[0]+ds, optname, len)) + return false; + + /* it's --optname, check how the parameter is supplied */ + if (argv[0][ds+len] == '=') { + *out = argv[0]+ds+len+1; + return true; + } + + if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */ + return false; + + /* using --opt param */ + *out = argv[1]; + --*argc_; + ++*argv_; + return true; +} + +int main(int argc, char **argv) { + bool extract = true; + char *redirout = (char*)stdout; + char *redirerr = (char*)stderr; + char *file = NULL; + char **files = NULL; + pak_file_t *pak = NULL; + size_t iter = 0; + + con_init(); + + /* + * Command line option parsing commences now We only need to support + * a few things in the test suite. + */ + while (argc > 1) { + ++argv; + --argc; + + if (argv[0][0] == '-') { + if (parsecmd("redirout", &argc, &argv, &redirout, 1, false)) + continue; + if (parsecmd("redirerr", &argc, &argv, &redirerr, 1, false)) + continue; + if (parsecmd("file", &argc, &argv, &file, 1, false)) + continue; + + con_change(redirout, redirerr); + + switch (argv[0][1]) { + case 'e': extract = true; continue; + case 'c': extract = false; continue; + } + + if (!strcmp(argv[0]+1, "debug")) { + OPTS_OPTION_BOOL(OPTION_DEBUG) = true; + continue; + } + if (!strcmp(argv[0]+1, "memchk")) { + OPTS_OPTION_BOOL(OPTION_MEMCHK) = true; + continue; + } + if (!strcmp(argv[0]+1, "nocolor")) { + con_color(0); + continue; + } + } + + vec_push(files, argv[0]); + } + con_change(redirout, redirerr); + + + if (!file) { + con_err("-file must be specified for output/input PAK file\n"); + vec_free(files); + return EXIT_FAILURE; + } + + if (extract) { + if (!(pak = pak_open(file, "r"))) { + con_err("failed to open PAK file %s\n", file); + vec_free(files); + return EXIT_FAILURE; + } + + if (!pak_extract_all(pak, "./")) { + con_err("failed to extract PAK %s (files may be missing)\n", file); + pak_close(pak); + vec_free(files); + return EXIT_FAILURE; + } + + /* not possible */ + pak_close(pak); + vec_free(files); + util_meminfo(); + return EXIT_SUCCESS; + } + + if (!(pak = pak_open(file, "w"))) { + con_err("failed to open PAK %s for writing\n", file); + vec_free(files); + return EXIT_FAILURE; + } + + for (iter = 0; iter < vec_size(files); iter++) { + if (!(pak_insert_one(pak, files[iter]))) { + con_err("failed inserting %s for PAK %s\n", files[iter], file); + pak_close(pak); + vec_free(files); + return EXIT_FAILURE; + } + } + + /* not possible */ + pak_close(pak); + vec_free(files); + + + util_meminfo(); + return EXIT_SUCCESS; +}