AllocWinding: fix handling of compiler enforced alignment of double
[divverent/netradiant.git] / tools / quake3 / common / vfs.c
1 /*
2 Copyright (c) 2001, Loki software, inc.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without modification, 
6 are permitted provided that the following conditions are met:
7   
8 Redistributions of source code must retain the above copyright notice, this list 
9 of conditions and the following disclaimer.
10     
11 Redistributions in binary form must reproduce the above copyright notice, this
12 list of conditions and the following disclaimer in the documentation and/or
13 other materials provided with the distribution.
14       
15 Neither the name of Loki software nor the names of its contributors may be used 
16 to endorse or promote products derived from this software without specific prior 
17 written permission. 
18         
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' 
20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
22 DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY 
23 DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
24 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
25 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
26 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
27 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
28 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
29 */
30
31 //
32 // Rules:
33 //
34 // - Directories should be searched in the following order: ~/.q3a/baseq3,
35 //   install dir (/usr/local/games/quake3/baseq3) and cd_path (/mnt/cdrom/baseq3).
36 //
37 // - Pak files are searched first inside the directories.
38 // - Case insensitive.
39 // - Unix-style slashes (/) (windows is backwards .. everyone knows that)
40 //
41 // Leonardo Zide (leo@lokigames.com)
42 //
43
44 #include <string.h>
45 #include <stdlib.h>
46 #include <sys/stat.h>
47
48 #include "cmdlib.h"
49 #include "filematch.h"
50 #include "mathlib.h"
51 #include "inout.h"
52 #include "vfs.h"
53 #include "unzip.h"
54
55 typedef struct
56 {
57   char*   name;
58   unz_s   zipinfo;
59   unzFile zipfile;
60   guint32   size;
61 } VFS_PAKFILE;
62
63 // =============================================================================
64 // Global variables
65
66 static GSList*  g_unzFiles;
67 static GSList*  g_pakFiles;
68 static char     g_strDirs[VFS_MAXDIRS][PATH_MAX+1];
69 static int      g_numDirs;
70 char     g_strForbiddenDirs[VFS_MAXDIRS][PATH_MAX+1];
71 int      g_numForbiddenDirs = 0;
72 static gboolean g_bUsePak = TRUE;
73
74 // =============================================================================
75 // Static functions
76
77 static void vfsAddSlash (char *str)
78 {
79   int n = strlen (str);
80   if (n > 0)
81   {
82     if (str[n-1] != '\\' && str[n-1] != '/')
83       strcat (str, "/");
84   }
85 }
86
87 static void vfsFixDOSName (char *src)
88 {
89   if (src == NULL)
90     return;
91   
92   while (*src)
93   {
94     if (*src == '\\')
95       *src = '/';
96     src++;
97   }
98 }
99
100 //!\todo Define globally or use heap-allocated string.
101 #define NAME_MAX 255
102
103 static void vfsInitPakFile (const char *filename)
104 {
105   unz_global_info gi;
106   unzFile uf;
107   guint32 i;
108   int err;
109   
110   uf = unzOpen (filename);
111   if (uf == NULL)
112     return;
113   
114   g_unzFiles = g_slist_append (g_unzFiles, uf);
115   
116   err = unzGetGlobalInfo (uf,&gi);
117   if (err != UNZ_OK)
118     return;
119   unzGoToFirstFile(uf);
120   
121   for (i = 0; i < gi.number_entry; i++)
122   {
123     char filename_inzip[NAME_MAX];
124     unz_file_info file_info;
125     VFS_PAKFILE* file;
126     
127     err = unzGetCurrentFileInfo (uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
128     if (err != UNZ_OK)
129       break;
130     
131     file = (VFS_PAKFILE*)safe_malloc (sizeof (VFS_PAKFILE));
132     g_pakFiles = g_slist_append (g_pakFiles, file);
133     
134     vfsFixDOSName (filename_inzip);
135     g_strdown (filename_inzip);
136     
137     file->name = strdup (filename_inzip);
138     file->size = file_info.uncompressed_size;
139     file->zipfile = uf;
140     memcpy (&file->zipinfo, uf, sizeof (unz_s));
141     
142     if ((i+1) < gi.number_entry)
143     {
144       err = unzGoToNextFile(uf);
145       if (err!=UNZ_OK)
146         break;
147     }
148   }
149 }
150
151 // =============================================================================
152 // Global functions
153
154 // reads all pak files from a dir
155 void vfsInitDirectory (const char *path)
156 {
157   char filename[PATH_MAX];
158   char *dirlist;
159   GDir *dir;
160   int j;
161
162   for(j = 0; j < g_numForbiddenDirs; ++j)
163   {
164     char* dbuf = g_strdup(path);
165     if(*dbuf && dbuf[strlen(dbuf)-1] == '/')
166       dbuf[strlen(dbuf)-1] = 0;
167     const char *p = strrchr(dbuf, '/');
168     p = (p ? (p+1) : dbuf);
169     if(matchpattern(p, g_strForbiddenDirs[j], TRUE))
170     {
171       g_free(dbuf);
172       break;
173     }
174     g_free(dbuf);
175   }
176   if(j < g_numForbiddenDirs)
177     return;
178   
179   if (g_numDirs == VFS_MAXDIRS)
180     return;
181   
182   Sys_Printf ("VFS Init: %s\n", path);
183   
184   strncpy (g_strDirs[g_numDirs], path, PATH_MAX);
185   g_strDirs[g_numDirs][PATH_MAX] = 0;
186   vfsFixDOSName (g_strDirs[g_numDirs]);
187   vfsAddSlash (g_strDirs[g_numDirs]);
188   g_numDirs++;
189   
190   if (g_bUsePak)
191   {
192     dir = g_dir_open (path, 0, NULL);
193
194     if (dir != NULL)
195     {
196       while (1)
197       {
198         const char* name = g_dir_read_name(dir);
199         if(name == NULL)
200           break;
201
202         for(j = 0; j < g_numForbiddenDirs; ++j)
203         {
204           const char *p = strrchr(name, '/');
205           p = (p ? (p+1) : name);
206           if(matchpattern(p, g_strForbiddenDirs[j], TRUE))
207             break;
208         }
209         if(j < g_numForbiddenDirs)
210           continue;
211
212         dirlist = g_strdup(name);
213
214         {
215           char *ext = strrchr (dirlist, '.');
216
217           if(ext && !Q_stricmp(ext, ".pk3dir"))
218           {
219             if (g_numDirs == VFS_MAXDIRS)
220               continue;
221             snprintf(g_strDirs[g_numDirs], PATH_MAX, "%s/%s", path, name);
222             g_strDirs[g_numDirs][PATH_MAX] = '\0';
223             vfsFixDOSName (g_strDirs[g_numDirs]);
224             vfsAddSlash (g_strDirs[g_numDirs]);
225             ++g_numDirs;
226           }
227
228           if ((ext == NULL) || (Q_stricmp (ext, ".pk3") != 0))
229             continue;
230         }
231         
232         sprintf (filename, "%s/%s", path, dirlist);
233         vfsInitPakFile (filename);
234
235         g_free(dirlist);
236       }
237       g_dir_close (dir);
238     }
239   }
240 }
241
242 // frees all memory that we allocated
243 void vfsShutdown ()
244 {
245   while (g_unzFiles)
246   {
247     unzClose ((unzFile)g_unzFiles->data);
248     g_unzFiles = g_slist_remove (g_unzFiles, g_unzFiles->data);
249   }
250   
251   while (g_pakFiles)
252   {
253     VFS_PAKFILE* file = (VFS_PAKFILE*)g_pakFiles->data;
254     free (file->name);
255     free (file);
256     g_pakFiles = g_slist_remove (g_pakFiles, file);
257   }
258 }
259
260 // return the number of files that match
261 int vfsGetFileCount (const char *filename)
262 {
263   int i, count = 0;
264   char fixed[NAME_MAX], tmp[NAME_MAX];
265   GSList *lst;
266   
267   strcpy (fixed, filename);
268   vfsFixDOSName (fixed);
269   g_strdown (fixed);
270   
271   for (lst = g_pakFiles; lst != NULL; lst = g_slist_next (lst))
272   {
273     VFS_PAKFILE* file = (VFS_PAKFILE*)lst->data;
274     
275     if (strcmp (file->name, fixed) == 0)
276       count++;
277   }
278   
279   for (i = 0; i < g_numDirs; i++)
280   {
281     strcpy (tmp, g_strDirs[i]);
282     strcat (tmp, fixed);
283     if (access (tmp, R_OK) == 0)
284       count++;
285   }
286   
287   return count;
288 }
289
290 // NOTE: when loading a file, you have to allocate one extra byte and set it to \0
291 int vfsLoadFile (const char *filename, void **bufferptr, int index)
292 {
293   int i, count = 0;
294   char tmp[NAME_MAX], fixed[NAME_MAX];
295   GSList *lst;
296   
297   // filename is a full path
298   if (index == -1)
299   {
300     long len;
301     FILE *f;
302     
303     f = fopen (filename, "rb");
304     if (f == NULL)
305       return -1;
306     
307     fseek (f, 0, SEEK_END);
308     len = ftell (f);
309     rewind (f);
310     
311     *bufferptr = safe_malloc (len+1);
312     if (*bufferptr == NULL)
313         {
314                 fclose(f);
315                 return -1;
316         }
317     
318     if(fread (*bufferptr, 1, len, f) != (size_t) len)
319         {
320                 fclose(f);
321                 return -1;
322         }
323     fclose (f);
324     
325     // we need to end the buffer with a 0
326     ((char*) (*bufferptr))[len] = 0;
327     
328     return len;
329   }
330   
331   *bufferptr = NULL;
332   strcpy (fixed, filename);
333   vfsFixDOSName (fixed);
334   g_strdown (fixed);
335   
336   for (i = 0; i < g_numDirs; i++)
337   {
338     strcpy (tmp, g_strDirs[i]);
339     strcat (tmp, filename);
340     if (access (tmp, R_OK) == 0)
341     {
342       if (count == index)
343       {
344         long len;
345         FILE *f;
346         
347         f = fopen (tmp, "rb");
348         if (f == NULL)
349           return -1;
350         
351         fseek (f, 0, SEEK_END);
352         len = ftell (f);
353         rewind (f);
354         
355         *bufferptr = safe_malloc (len+1);
356         if (*bufferptr == NULL)
357                 {
358                   fclose(f);
359           return -1;
360                 }
361         
362         if(fread (*bufferptr, 1, len, f) != (size_t) len)
363                 {
364                   fclose(f);
365           return -1;
366                 }
367         fclose (f);
368         
369         // we need to end the buffer with a 0
370         ((char*) (*bufferptr))[len] = 0;
371         
372         return len;
373       }
374       
375       count++;
376     }
377   }
378   
379   for (lst = g_pakFiles; lst != NULL; lst = g_slist_next (lst))
380   {
381     VFS_PAKFILE* file = (VFS_PAKFILE*)lst->data;
382     
383     if (strcmp (file->name, fixed) != 0)
384       continue;
385     
386     if (count == index)
387     {
388       memcpy (file->zipfile, &file->zipinfo, sizeof (unz_s));
389       
390       if (unzOpenCurrentFile (file->zipfile) != UNZ_OK)
391         return -1;
392       
393       *bufferptr = safe_malloc (file->size+1);
394       // we need to end the buffer with a 0
395       ((char*) (*bufferptr))[file->size] = 0;
396       
397       i = unzReadCurrentFile (file->zipfile , *bufferptr, file->size);
398       unzCloseCurrentFile (file->zipfile);
399       if (i < 0)
400         return -1;
401       else
402         return file->size;
403     }
404     
405     count++;
406   }
407   
408   return -1;
409 }