4bf7e5f423f4f96666b72009ec5f1f7763b062d9
[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     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 = (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, 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     FILE            *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, 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     FILE           *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, SEEK_END) != 0 || ((len = fs_file_tell(fp)) < 0))
355         goto err;
356     if (fs_file_seek(fp, 0, 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 bool pak_insert_all(pak_file_t *pak, const char *dir) {
400     DIR           *dp;
401     struct dirent *dirp;
402
403     if (!(pak->insert))
404         return false;
405
406     if (!(dp = fs_dir_open(dir)))
407         return false;
408
409     while ((dirp = fs_dir_read(dp))) {
410         if (!(pak_insert_one(pak, dirp->d_name))) {
411             fs_dir_close(dp);
412             return false;
413         }
414     }
415
416     fs_dir_close(dp);
417     return true;
418 }
419
420 static bool pak_close(pak_file_t *pak) {
421     size_t itr;
422     long   tell;
423
424     if (!pak)
425         return false;
426
427     /*
428      * In insert mode we need to patch the header, and write
429      * our directory entries at the end of the file.
430      */
431     if (pak->insert) {
432         if ((tell = fs_file_tell(pak->handle)) != 0)
433             goto err;
434
435         pak->header.dirlen = vec_size(pak->directories) * 64;
436         pak->header.diroff = tell;
437
438         /* patch header */
439         if (fs_file_seek (pak->handle, 0, SEEK_SET) != 0)
440             goto err;
441
442         fs_file_write(&(pak->header), sizeof(pak_header_t), 1, pak->handle);
443
444         /* write directories */
445         if (fs_file_seek (pak->handle, pak->header.diroff, SEEK_SET) != 0)
446             goto err;
447
448         for (itr = 0; itr < vec_size(pak->directories); itr++) {
449             fs_file_write(&(pak->directories[itr]), sizeof(pak_directory_t), 1, pak->handle);
450         }
451     }
452
453     vec_free     (pak->directories);
454     fs_file_close(pak->handle);
455     mem_d        (pak);
456
457     return true;
458
459 err:
460     vec_free     (pak->directories);
461     fs_file_close(pak->handle);
462     mem_d        (pak);
463
464     return false;
465 }
466
467 /*
468  * Fancy GCC-like LONG parsing allows things like --opt=param with
469  * assignment operator.  This is used for redirecting stdout/stderr
470  * console to specific files of your choice.
471  */
472 static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
473     int  argc   = *argc_;
474     char **argv = *argv_;
475
476     size_t len = strlen(optname);
477
478     if (strncmp(argv[0]+ds, optname, len))
479         return false;
480
481     /* it's --optname, check how the parameter is supplied */
482     if (argv[0][ds+len] == '=') {
483         *out = argv[0]+ds+len+1;
484         return true;
485     }
486
487     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
488         return false;
489
490     /* using --opt param */
491     *out = argv[1];
492     --*argc_;
493     ++*argv_;
494     return true;
495 }
496
497 int main(int argc, char **argv) {
498     bool          extract   = true;
499     char         *redirout  = (char*)stdout;
500     char         *redirerr  = (char*)stderr;
501     char         *file      = NULL;
502     char        **files     = NULL;
503     pak_file_t   *pak       = NULL;
504     size_t        iter      = 0;
505
506     con_init();
507
508     /*
509      * Command line option parsing commences now We only need to support
510      * a few things in the test suite.
511      */
512     while (argc > 1) {
513         ++argv;
514         --argc;
515
516         if (argv[0][0] == '-') {
517             if (parsecmd("redirout",  &argc, &argv, &redirout,  1, false))
518                 continue;
519             if (parsecmd("redirerr",  &argc, &argv, &redirerr,  1, false))
520                 continue;
521             if (parsecmd("file",      &argc, &argv, &file,      1, false))
522                 continue;
523
524             con_change(redirout, redirerr);
525
526             switch (argv[0][1]) {
527                 case 'e': extract = true;  continue;
528                 case 'c': extract = false; continue;
529             }
530
531             if (!strcmp(argv[0]+1, "debug")) {
532                 OPTS_OPTION_BOOL(OPTION_DEBUG) = true;
533                 continue;
534             }
535             if (!strcmp(argv[0]+1, "memchk")) {
536                 OPTS_OPTION_BOOL(OPTION_MEMCHK) = true;
537                 continue;
538             }
539             if (!strcmp(argv[0]+1, "nocolor")) {
540                 con_color(0);
541                 continue;
542             }
543         }
544
545         vec_push(files, argv[0]);
546     }
547     con_change(redirout, redirerr);
548
549
550     if (!file) {
551         con_err("-file must be specified for output/input PAK file\n");
552         vec_free(files);
553         return EXIT_FAILURE;
554     }
555
556     if (extract) {
557         if (!(pak = pak_open(file, "r"))) {
558             con_err("failed to open PAK file %s\n", file);
559             vec_free(files);
560             return EXIT_FAILURE;
561         }
562
563         if (!pak_extract_all(pak, "./")) {
564             con_err("failed to extract PAK %s (files may be missing)\n", file);
565             pak_close(pak);
566             vec_free(files);
567             return EXIT_FAILURE;
568         }
569
570         /* not possible */
571         pak_close(pak);
572         vec_free(files);
573         stat_info();
574
575         return EXIT_SUCCESS;
576     }
577
578     if (!(pak = pak_open(file, "w"))) {
579         con_err("failed to open PAK %s for writing\n", file);
580         vec_free(files);
581         return EXIT_FAILURE;
582     }
583
584     for (iter = 0; iter < vec_size(files); iter++) {
585         if (!(pak_insert_one(pak, files[iter]))) {
586             con_err("failed inserting %s for PAK %s\n", files[iter], file);
587             pak_close(pak);
588             vec_free(files);
589             return EXIT_FAILURE;
590         }
591     }
592
593     /* not possible */
594     pak_close(pak);
595     vec_free(files);
596
597     stat_info();
598     return EXIT_SUCCESS;
599 }