X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=pak.c;h=653a4630a133905d62c99845c9902e15dddf3566;hp=494ad7fd466679791f24fa40c640b51322fc7303;hb=69b55ccc03b56af1f6c05eb45866ab198307487f;hpb=533b2144c554179ba1375e3e49bee6a18715977f

diff --git a/pak.c b/pak.c
index 494ad7f..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,14 +20,12 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-#include <sys/stat.h>
-#include <dirent.h>
 #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' | ('A' << 8) | ('C' << 16) | ('K' << 24))))
 
 typedef struct {
@@ -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);
 
@@ -476,7 +480,6 @@ int main(int argc, char **argv) {
     bool          extract   = true;
     char         *redirout  = (char*)stdout;
     char         *redirerr  = (char*)stderr;
-    char         *directory = NULL;
     char         *file      = NULL;
     char        **files     = NULL;
     pak_file_t   *pak       = NULL;
@@ -497,8 +500,6 @@ int main(int argc, char **argv) {
                 continue;
             if (parsecmd("redirerr",  &argc, &argv, &redirerr,  1, false))
                 continue;
-            if (parsecmd("directory", &argc, &argv, &directory, 1, false))
-                continue;
             if (parsecmd("file",      &argc, &argv, &file,      1, false))
                 continue;
 
@@ -541,7 +542,7 @@ int main(int argc, char **argv) {
             return EXIT_FAILURE;
         }
 
-        if (!pak_extract_all(pak, (directory) ? directory : "./")) {
+        if (!pak_extract_all(pak, "./")) {
             con_err("failed to extract PAK %s (files may be missing)\n", file);
             pak_close(pak);
             vec_free(files);
@@ -561,13 +562,6 @@ int main(int argc, char **argv) {
         return EXIT_FAILURE;
     }
 
-    if (directory && !fs_dir_change(directory)) {
-        con_err("failed to change directory %s\n", directory);
-        pak_close(pak);
-        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);