6fdd88b83a61b9e288b0849f2151c250ab288272
[xonotic/gmqcc.git] / 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 <string.h>
24 #include <stdlib.h>
25
26 #include "gmqcc.h"
27
28 /*
29  * The PAK format uses a FOURCC concept for storing the magic ident within
30  * the header as a uint32_t.
31  */
32 #define PAK_FOURCC ((uint32_t)(((uint8_t)'P'|((uint8_t)'A'<<8)|((uint8_t)'C'<<16)|((uint8_t)'K'<<24))))
33
34 typedef struct {
35     uint32_t magic;  /* "PACK" */
36
37     /*
38      * Offset to first directory entry in PAK file.  It's often
39      * best to store the directories at the end of the file opposed
40      * to the front, since it allows easy insertion without having
41      * to load the entire file into memory again.
42      */
43     uint32_t diroff;
44     uint32_t dirlen;
45 } pak_header_t;
46
47 /*
48  * A directory, is sort of a "file entry".  The concept of
49  * a directory in Quake world is a "file entry/record". This
50  * describes a file (with directories/nested ones too in it's
51  * file name).  Hence it can be a file, file with directory, or
52  * file with directories.
53  */
54 typedef struct {
55     char     name[56];
56     uint32_t pos;
57     uint32_t len;
58 } pak_directory_t;
59
60 /*
61  * Used to get the next token from a string, where the
62  * strings themselfs are seperated by chracters from
63  * `sep`.  This is essentially strsep.
64  */
65 static char *pak_tree_sep(char **str, const char *sep) {
66     char *beg = *str;
67     char *end;
68
69     if (!beg)
70         return NULL;
71
72     if (*(end = beg + strcspn(beg, sep)))
73         * end++ = '\0'; /* null terminate */
74     else
75           end   = 0;
76
77     *str = end;
78     return beg;
79 }
80
81 /*
82  * When given a string like "a/b/c/d/e/file"
83  * this function will handle the creation of
84  * the directory structure, included nested
85  * directories.
86  */
87 static void pak_tree_build(const char *entry) {
88     char *directory;
89     char *elements[28];
90     char *pathsplit;
91     char *token;
92
93     size_t itr;
94     size_t jtr;
95
96     pathsplit = (char *)mem_a(56);
97     directory = (char *)mem_a(56);
98
99     memset(pathsplit, 0, 56);
100
101     util_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         util_strcat(pathsplit, elements[jtr]);
108         util_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     fs_file_t       *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 = (pak_file_t*)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, FS_FILE_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 = (pak_file_t*)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         mem_d(pak);
201         return NULL;
202     }
203
204     memset(&(pak->header), 0, sizeof(pak_header_t));
205
206     /*
207      * We're in "insert" mode, we need to do things like header
208      * "patching" and writing the directories at the end of the
209      * file.
210      */
211     pak->insert       = true;
212     pak->header.magic = PAK_FOURCC;
213
214     /* on BE systems we need to swap the byte order of the FOURCC */
215     util_endianswap(&pak->header.magic, 1, sizeof(uint32_t));
216
217     /*
218      * We need to write out the header since files will be wrote out to
219      * this even with directory entries, and that not wrote.  The header
220      * will need to be patched in later with a file_seek, and overwrite,
221      * we could use offsets and other trickery.  This is just easier.
222      */
223     fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
224
225     return pak;
226 }
227
228 static pak_file_t *pak_open(const char *file, const char *mode) {
229     if (!file || !mode)
230         return NULL;
231
232     switch (*mode) {
233         case 'r': return pak_open_read (file);
234         case 'w': return pak_open_write(file);
235     }
236
237     return NULL;
238 }
239
240 static bool pak_exists(pak_file_t *pak, const char *file, pak_directory_t **dir) {
241     size_t itr;
242
243     if (!pak || !file)
244         return false;
245
246     for (itr = 0; itr < vec_size(pak->directories); itr++) {
247         if (!strcmp(pak->directories[itr].name, file)) {
248             /*
249              * Store back a pointer to the directory that matches
250              * the request if requested (NULL is not allowed).
251              */
252             if (dir) {
253                 *dir = &(pak->directories[itr]);
254             }
255             return true;
256         }
257     }
258
259     return false;
260 }
261
262 /*
263  * Extraction abilities.  These work as you expect them to.
264  */
265 static bool pak_extract_one(pak_file_t *pak, const char *file, const char *outdir) {
266     pak_directory_t *dir   = NULL;
267     unsigned char   *dat   = NULL;
268     char            *local = NULL;
269     fs_file_t       *out   = NULL;
270
271     if (!pak_exists(pak, file, &dir)) {
272         return false;
273     }
274
275     if (!(dat = (unsigned char *)mem_a(dir->len)))
276         goto err;
277
278     /*
279      * Generate the directory structure / tree that will be required
280      * to store the extracted file.
281      */
282     pak_tree_build(file);
283
284     /* TODO portable path seperators */
285     util_asprintf(&local, "%s/%s", outdir, file);
286
287     /*
288      * Now create the file, if this operation fails.  Then abort
289      * It shouldn't fail though.
290      */
291     if (!(out = fs_file_open(local, "wb")))
292         goto err;
293
294     /* free memory for directory string */
295     mem_d(local);
296
297     /* read */
298     if (fs_file_seek (pak->handle, dir->pos, FS_FILE_SEEK_SET) != 0)
299         goto err;
300
301     fs_file_read (dat, 1, dir->len, pak->handle);
302     fs_file_write(dat, 1, dir->len, out);
303     fs_file_close(out);
304
305     mem_d(dat);
306     return true;
307
308 err:
309     if (dat) mem_d(dat);
310     if (out) fs_file_close(out);
311     return false;
312 }
313
314 static bool pak_extract_all(pak_file_t *pak, const char *dir) {
315     size_t itr;
316
317     if (!fs_dir_make(dir))
318         return false;
319
320     for (itr = 0; itr < vec_size(pak->directories); itr++) {
321         if (!pak_extract_one(pak, pak->directories[itr].name, dir))
322             return false;
323     }
324
325     return true;
326 }
327
328 /*
329  * Insertion functions (the opposite of extraction).  Yes for generating
330  * PAKs.
331  */
332 static bool pak_insert_one(pak_file_t *pak, const char *file) {
333     pak_directory_t dir;
334     unsigned char  *dat;
335     long            len;
336     fs_file_t      *fp;
337
338     /*
339      * We don't allow insertion on files that already exist within the
340      * pak file.  Weird shit can happen if we allow that ;). We also
341      * don't allow insertion if the pak isn't opened in write mode.
342      */
343     if (!pak || !file || !pak->insert || pak_exists(pak, file, NULL))
344         return false;
345
346     if (!(fp = fs_file_open(file, "rb")))
347         return false;
348
349     /*
350      * Calculate the total file length, since it will be wrote to
351      * the directory entry, and the actual contents of the file
352      * to the PAK file itself.
353      */
354     if (fs_file_seek(fp, 0, FS_FILE_SEEK_END) != 0 || ((len = fs_file_tell(fp)) < 0))
355         goto err;
356     if (fs_file_seek(fp, 0, FS_FILE_SEEK_SET) != 0)
357         goto err;
358
359     dir.len = len;
360     dir.pos = fs_file_tell(pak->handle);
361
362     /*
363      * We're limited to 56 bytes for a file name string, that INCLUDES
364      * the directory and '/' seperators.
365      */
366     if (strlen(file) >= 56)
367         goto err;
368
369     util_strncpy(dir.name, file, strlen(file));
370
371     /*
372      * Allocate some memory for loading in the data that will be
373      * redirected into the PAK file.
374      */
375     if (!(dat = (unsigned char *)mem_a(dir.len)))
376         goto err;
377
378     fs_file_read (dat, dir.len, 1, fp);
379     fs_file_close(fp);
380     fs_file_write(dat, dir.len, 1, pak->handle);
381
382     /*
383      * Now add the directory to the directories vector, so pak_close
384      * can actually write it.
385      */
386     vec_push(pak->directories, dir);
387
388     return true;
389
390 err:
391     fs_file_close(fp);
392     return false;
393 }
394
395 /*
396  * Like pak_insert_one, except this collects files in all directories
397  * from a root directory, and inserts them all.
398  */
399 #if 0
400 static bool pak_insert_all(pak_file_t *pak, const char *dir) {
401     DIR           *dp;
402     struct dirent *dirp;
403
404     if (!(pak->insert))
405         return false;
406
407     if (!(dp = fs_dir_open(dir)))
408         return false;
409
410     while ((dirp = fs_dir_read(dp))) {
411         if (!(pak_insert_one(pak, dirp->d_name))) {
412             fs_dir_close(dp);
413             return false;
414         }
415     }
416
417     fs_dir_close(dp);
418     return true;
419 }
420 #endif /*!if 0 renable when ready to use */
421
422 static bool pak_close(pak_file_t *pak) {
423     size_t itr;
424     long   tell;
425
426     if (!pak)
427         return false;
428
429     /*
430      * In insert mode we need to patch the header, and write
431      * our directory entries at the end of the file.
432      */
433     if (pak->insert) {
434         if ((tell = fs_file_tell(pak->handle)) != 0)
435             goto err;
436
437         pak->header.dirlen = vec_size(pak->directories) * 64;
438         pak->header.diroff = tell;
439
440         /* patch header */
441         if (fs_file_seek (pak->handle, 0, FS_FILE_SEEK_SET) != 0)
442             goto err;
443
444         fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
445
446         /* write directories */
447         if (fs_file_seek (pak->handle, pak->header.diroff, FS_FILE_SEEK_SET) != 0)
448             goto err;
449
450         for (itr = 0; itr < vec_size(pak->directories); itr++)
451             fs_file_write(&(pak->directories[itr]), sizeof(pak_directory_t), 1, pak->handle);
452     }
453
454     vec_free     (pak->directories);
455     fs_file_close(pak->handle);
456     mem_d        (pak);
457
458     return true;
459
460 err:
461     vec_free     (pak->directories);
462     fs_file_close(pak->handle);
463     mem_d        (pak);
464
465     return false;
466 }
467
468 /*
469  * Fancy GCC-like LONG parsing allows things like --opt=param with
470  * assignment operator.  This is used for redirecting stdout/stderr
471  * console to specific files of your choice.
472  */
473 static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
474     int  argc   = *argc_;
475     char **argv = *argv_;
476
477     size_t len = strlen(optname);
478
479     if (strncmp(argv[0]+ds, optname, len))
480         return false;
481
482     /* it's --optname, check how the parameter is supplied */
483     if (argv[0][ds+len] == '=') {
484         *out = argv[0]+ds+len+1;
485         return true;
486     }
487
488     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
489         return false;
490
491     /* using --opt param */
492     *out = argv[1];
493     --*argc_;
494     ++*argv_;
495     return true;
496 }
497
498 #include <stdio.h>
499 int main(int argc, char **argv) {
500     bool          extract   = true;
501     char         *redirout  = (char*)stdout;
502     char         *redirerr  = (char*)stderr;
503     char         *file      = NULL;
504     char        **files     = NULL;
505     pak_file_t   *pak       = NULL;
506     size_t        iter      = 0;
507
508     con_init();
509
510     /*
511      * Command line option parsing commences now We only need to support
512      * a few things in the test suite.
513      */
514     while (argc > 1) {
515         ++argv;
516         --argc;
517
518         if (argv[0][0] == '-') {
519             if (parsecmd("redirout",  &argc, &argv, &redirout,  1, false))
520                 continue;
521             if (parsecmd("redirerr",  &argc, &argv, &redirerr,  1, false))
522                 continue;
523             if (parsecmd("file",      &argc, &argv, &file,      1, false))
524                 continue;
525
526             con_change(redirout, redirerr);
527
528             switch (argv[0][1]) {
529                 case 'e': extract = true;  continue;
530                 case 'c': extract = false; continue;
531             }
532
533             if (!strcmp(argv[0]+1, "debug")) {
534                 OPTS_OPTION_BOOL(OPTION_DEBUG) = true;
535                 continue;
536             }
537             if (!strcmp(argv[0]+1, "memchk")) {
538                 OPTS_OPTION_BOOL(OPTION_MEMCHK) = true;
539                 continue;
540             }
541             if (!strcmp(argv[0]+1, "nocolor")) {
542                 con_color(0);
543                 continue;
544             }
545         }
546
547         vec_push(files, argv[0]);
548     }
549     con_change(redirout, redirerr);
550
551
552     if (!file) {
553         con_err("-file must be specified for output/input PAK file\n");
554         vec_free(files);
555         return EXIT_FAILURE;
556     }
557
558     if (extract) {
559         if (!(pak = pak_open(file, "r"))) {
560             con_err("failed to open PAK file %s\n", file);
561             vec_free(files);
562             return EXIT_FAILURE;
563         }
564
565         if (!pak_extract_all(pak, "./")) {
566             con_err("failed to extract PAK %s (files may be missing)\n", file);
567             pak_close(pak);
568             vec_free(files);
569             return EXIT_FAILURE;
570         }
571
572         /* not possible */
573         pak_close(pak);
574         vec_free(files);
575         stat_info();
576
577         return EXIT_SUCCESS;
578     }
579
580     if (!(pak = pak_open(file, "w"))) {
581         con_err("failed to open PAK %s for writing\n", file);
582         vec_free(files);
583         return EXIT_FAILURE;
584     }
585
586     for (iter = 0; iter < vec_size(files); iter++) {
587         if (!(pak_insert_one(pak, files[iter]))) {
588             con_err("failed inserting %s for PAK %s\n", files[iter], file);
589             pak_close(pak);
590             vec_free(files);
591             return EXIT_FAILURE;
592         }
593     }
594
595     /* not possible */
596     pak_close(pak);
597     vec_free(files);
598
599     stat_info();
600     return EXIT_SUCCESS;
601 }