pak.c

   1 /*
   2  * Copyright (C) 2013
   3  *     Dale Weiler
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   6  * this software and associated documentation files (the "Software"), to deal in
   7  * the Software without restriction, including without limitation the rights to
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is furnished to do
  10  * so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in all
  13  * copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23 #include <sys/stat.h>
  24 #include <dirent.h>
  25 #include "gmqcc.h"
  26
  27 /*
  28  * The PAK format uses a FOURCC concept for storing the magic ident within
  29  * the header as a uint32_t.
  30  */
  31 #define PAK_FOURCC ((uint32_t)(('P' << 24) | ('A' << 16) | ('C' << 8) | 'K'))
  32
  33 typedef struct {
  34     uint32_t magic;  /* "PACK" */
  35
  36     /*
  37      * Offset to first directory entry in PAK file.  It's often
  38      * best to store the directories at the end of the file opposed
  39      * to the front, since it allows easy insertion without having
  40      * to load the entire file into memory again.
  41      */
  42     uint32_t diroff;
  43     uint32_t dirlen;
  44 } pak_header_t;
  45
  46 /*
  47  * A directory, is sort of a "file entry".  The concept of
  48  * a directory in Quake world is a "file entry/record". This
  49  * describes a file (with directories/nested ones too in it's
  50  * file name).  Hence it can be a file, file with directory, or
  51  * file with directories.
  52  */
  53 typedef struct {
  54     char     name[56];
  55     uint32_t pos;
  56     uint32_t len;
  57 } pak_directory_t;
  58
  59 /*
  60  * Used to get the next token from a string, where the
  61  * strings themselfs are seperated by chracters from
  62  * `sep`.  This is essentially strsep.
  63  */
  64 static char *pak_tree_sep(char **str, const char *sep) {
  65     char *beg = *str;
  66     char *end;
  67
  68     if (!beg)
  69         return NULL;
  70
  71     if (*(end = beg + strcspn(beg, sep)))
  72         * end++ = '\0'; /* null terminate */
  73     else
  74           end   = 0;
  75
  76     *str = end;
  77     return beg;
  78 }
  79
  80 /*
  81  * When given a string like "a/b/c/d/e/file"
  82  * this function will handle the creation of
  83  * the directory structure, included nested
  84  * directories.
  85  */
  86 static void pak_tree_build(const char *entry) {
  87     char *directory;
  88     char *elements[28];
  89     char *pathsplit;
  90     char *token;
  91
  92     size_t itr;
  93     size_t jtr;
  94
  95     pathsplit = mem_a(56);
  96     directory = mem_a(56);
  97
  98     memset(pathsplit, 0, 56);
  99     memset(directory, 0, 56);
 100
 101     strncpy(directory, entry, 56);
 102     for (itr = 0; (token = pak_tree_sep(&directory, "/")) != NULL; itr++) {
 103         elements[itr] = token;
 104     }
 105
 106     for (jtr = 0; jtr < itr - 1; jtr++) {
 107         strcat(pathsplit, elements[jtr]);
 108         strcat(pathsplit, "/");
 109
 110         if (fs_dir_make(pathsplit)) {
 111             mem_d(pathsplit);
 112             mem_d(directory);
 113
 114             /* TODO: undo on fail */
 115
 116             return;
 117         }
 118     }
 119
 120     mem_d(pathsplit);
 121     mem_d(directory);
 122 }
 123
 124 typedef struct {
 125     pak_directory_t *directories;
 126     pak_header_t     header;
 127     FILE            *handle;
 128     bool             insert;
 129 } pak_file_t;
 130
 131 static pak_file_t *pak_open_read(const char *file) {
 132     pak_file_t *pak;
 133     size_t      itr;
 134
 135     if (!(pak = mem_a(sizeof(pak_file_t))))
 136         return NULL;
 137
 138     if (!(pak->handle = fs_file_open(file, "rb"))) {
 139         mem_d(pak);
 140         return NULL;
 141     }
 142
 143     pak->directories = NULL;
 144     pak->insert      = false; /* read doesn't allow insert */
 145
 146     memset         (&pak->header, 0, sizeof(pak_header_t));
 147     fs_file_read   (&pak->header,    sizeof(pak_header_t), 1, pak->handle);
 148     util_endianswap(&pak->header, 1, sizeof(pak_header_t));
 149
 150     /*
 151      * Every PAK file has "PACK" stored as FOURCC data in the
 152      * header.  If this data cannot compare (as checked here), it's
 153      * probably not a PAK file.
 154      */
 155     if (pak->header.magic != PAK_FOURCC) {
 156         fs_file_close(pak->handle);
 157         mem_d        (pak);
 158         return NULL;
 159     }
 160
 161     /*
 162      * Time to read in the directory handles and prepare the directories
 163      * vector.  We're going to be reading some the file inwards soon.
 164      */
 165     fs_file_seek(pak->handle, pak->header.diroff, SEEK_SET);
 166
 167     /*
 168      * Read in all directories from the PAK file. These are considered
 169      * to be the "file entries".
 170      */
 171     for (itr = 0; itr < pak->header.dirlen / 64; itr++) {
 172         pak_directory_t dir;
 173         fs_file_read   (&dir,    sizeof(pak_directory_t), 1, pak->handle);
 174         util_endianswap(&dir, 1, sizeof(pak_directory_t));
 175
 176         vec_push(pak->directories, dir);
 177     }
 178     return pak;
 179 }
 180
 181 static pak_file_t *pak_open_write(const char *file) {
 182     pak_file_t *pak;
 183
 184     if (!(pak = mem_a(sizeof(pak_file_t))))
 185         return NULL;
 186
 187     /*
 188      * Generate the required directory structure / tree for
 189      * writing this PAK file too.
 190      */
 191     pak_tree_build(file);
 192
 193     if (!(pak->handle = fs_file_open(file, "wb"))) {
 194         /*
 195          * The directory tree that was created, needs to be
 196          * removed entierly if we failed to open a file.
 197          */
 198         /* TODO backup directory clean */
 199
 200         return NULL;
 201     }
 202
 203     memset(&(pak->header), 0, sizeof(pak_header_t));
 204
 205     /*
 206      * We're in "insert" mode, we need to do things like header
 207      * "patching" and writing the directories at the end of the
 208      * file.
 209      */
 210     pak->insert       = true;
 211     pak->header.magic = PAK_FOURCC;
 212
 213     /*
 214      * We need to write out the header since files will be wrote out to
 215      * this even with directory entries, and that not wrote.  The header
 216      * will need to be patched in later with a file_seek, and overwrite,
 217      * we could use offsets and other trickery.  This is just easier.
 218      */
 219     fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
 220
 221     return pak;
 222 }
 223
 224 pak_file_t *pak_open(const char *file, const char *mode) {
 225     if (!file || !mode)
 226         return NULL;
 227
 228     switch (*mode) {
 229         case 'r': return pak_open_read (file);
 230         case 'w': return pak_open_write(file);
 231     }
 232
 233     return NULL;
 234 }
 235
 236 bool pak_exists(pak_file_t *pak, const char *file, pak_directory_t **dir) {
 237     size_t itr;
 238
 239     if (!pak || !file)
 240         return false;
 241
 242     for (itr = 0; itr < vec_size(pak->directories); itr++) {
 243         if (!strcmp(pak->directories[itr].name, file)) {
 244             /*
 245              * Store back a pointer to the directory that matches
 246              * the request if requested (NULL is not allowed).
 247              */
 248             if (dir) {
 249                 *dir = &(pak->directories[itr]);
 250             }
 251             return true;
 252         }
 253     }
 254
 255     return false;
 256 }
 257
 258 /*
 259  * Extraction abilities.  These work as you expect them to.
 260  */
 261 bool pak_extract_one(pak_file_t *pak, const char *file) {
 262     pak_directory_t *dir = NULL;
 263     unsigned char   *dat = NULL;
 264     FILE            *out;
 265
 266     if (!pak_exists(pak, file, &dir)) {
 267         return false;
 268     }
 269
 270     if (!(dat = (unsigned char *)mem_a(dir->len))) {
 271         return false;
 272     }
 273
 274     /*
 275      * Generate the directory structure / tree that will be required
 276      * to store the extracted file.
 277      */
 278     pak_tree_build(file);
 279
 280     /*
 281      * Now create the file, if this operation fails.  Then abort
 282      * It shouldn't fail though.
 283      */
 284     if (!(out = fs_file_open(file, "wb"))) {
 285         mem_d(dat);
 286         return false;
 287     }
 288
 289
 290     /* read */
 291     fs_file_seek (pak->handle, dir->pos, SEEK_SET);
 292     fs_file_read (dat, 1, dir->len, pak->handle);
 293
 294     /* write */
 295     fs_file_write(dat, 1, dir->len, out);
 296
 297     /* close */
 298     fs_file_close(out);
 299
 300     /* free */
 301     mem_d(dat);
 302
 303     return true;
 304 }
 305
 306 bool pak_extract_all(pak_file_t *pak, const char *dir) {
 307     size_t itr;
 308
 309     if (!fs_dir_make(dir))
 310         return false;
 311
 312     if (fs_dir_change(dir))
 313         return false;
 314
 315     for (itr = 0; itr < vec_size(pak->directories); itr++) {
 316         if (!pak_extract_one(pak, pak->directories[itr].name))
 317             return false;
 318     }
 319
 320     return true;
 321 }
 322
 323 /*
 324  * Insertion functions (the opposite of extraction).  Yes for generating
 325  * PAKs.
 326  */
 327 bool pak_insert_one(pak_file_t *pak, const char *file) {
 328     pak_directory_t dir;
 329     unsigned char  *dat;
 330     FILE           *fp;
 331
 332     /*
 333      * We don't allow insertion on files that already exist within the
 334      * pak file.  Weird shit can happen if we allow that ;). We also
 335      * don't allow insertion if the pak isn't opened in write mode.
 336      */
 337     if (!pak || !file || !pak->insert || pak_exists(pak, file, NULL))
 338         return false;
 339
 340     if (!(fp = fs_file_open(file, "rb")))
 341         return false;
 342
 343     /*
 344      * Calculate the total file length, since it will be wrote to
 345      * the directory entry, and the actual contents of the file
 346      * to the PAK file itself.
 347      */
 348     fs_file_seek(fp, 0, SEEK_END);
 349     dir.len = fs_file_tell(fp);
 350     fs_file_seek(fp, 0, SEEK_SET);
 351
 352     dir.pos = fs_file_tell(pak->handle);
 353
 354     /*
 355      * We're limited to 56 bytes for a file name string, that INCLUDES
 356      * the directory and '/' seperators.
 357      */
 358     if (strlen(file) >= 56) {
 359         fs_file_close(fp);
 360         return false;
 361     }
 362
 363     strcpy(dir.name, file);
 364
 365     /*
 366      * Allocate some memory for loading in the data that will be
 367      * redirected into the PAK file.
 368      */
 369     if (!(dat = (unsigned char *)mem_a(dir.len))) {
 370         fs_file_close(fp);
 371         return false;
 372     }
 373
 374     fs_file_read (dat, dir.len, 1, fp);
 375     fs_file_close(fp);
 376     fs_file_write(dat, dir.len, 1, pak->handle);
 377
 378     /*
 379      * Now add the directory to the directories vector, so pak_close
 380      * can actually write it.
 381      */
 382     vec_push(pak->directories, dir);
 383
 384     return true;
 385 }
 386
 387 /*
 388  * Like pak_insert_one, except this collects files in all directories
 389  * from a root directory, and inserts them all.
 390  */
 391 bool pak_insert_all(pak_file_t *pak, const char *dir) {
 392     DIR           *dp;
 393     struct dirent *dirp;
 394
 395     if (!(pak->insert))
 396         return false;
 397
 398     if (!(dp = fs_dir_open(dir)))
 399         return false;
 400
 401     while ((dirp = fs_dir_read(dp))) {
 402         if (!(pak_insert_one(pak, dirp->d_name))) {
 403             fs_dir_close(dp);
 404             return false;
 405         }
 406     }
 407
 408     fs_dir_close(dp);
 409     return true;
 410 }
 411
 412 bool pak_close(pak_file_t *pak) {
 413     size_t itr;
 414
 415     if (!pak)
 416         return false;
 417
 418     /*
 419      * In insert mode we need to patch the header, and write
 420      * our directory entries at the end of the file.
 421      */
 422     if (pak->insert) {
 423         pak->header.dirlen = vec_size(pak->directories) * 64;
 424         pak->header.diroff = ftell(pak->handle);
 425
 426         /* patch header */
 427         fs_file_seek (pak->handle, 0, SEEK_SET);
 428         fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
 429
 430         /* write directories */
 431         fs_file_seek (pak->handle, pak->header.diroff, SEEK_SET);
 432
 433         for (itr = 0; itr < vec_size(pak->directories); itr++) {
 434             fs_file_write(&(pak->directories[itr]), sizeof(pak_directory_t), 1, pak->handle);
 435         }
 436     }
 437
 438     vec_free     (pak->directories);
 439     fs_file_close(pak->handle);
 440     mem_d        (pak);
 441
 442     return true;
 443 }