/
zip.c
675 lines (542 loc) · 18.2 KB
1
2
3
4
5
6
7
8
/*
* ZIP support routines for PhysicsFS.
*
* Please see the file LICENSE in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
9
10
11
12
13
/*
* !!! FIXME: overall design bugs.
*
* Maybe add a seekToStartOfCurrentFile() in unzip.c if complete seek
* semantics are impossible.
14
15
16
*
* Could be more i/o efficient if we combined unzip.c and this file.
* (and thus lose all the unzGoToNextFile() dummy loops.
17
*/
18
19
20
#include <stdio.h>
#include <stdlib.h>
21
#include <string.h>
22
#include <errno.h>
23
#include <assert.h>
24
#include "physfs.h"
25
26
#include "unzip.h"
27
28
29
30
31
32
33
34
#define __PHYSICSFS_INTERNAL__
#include "physfs_internal.h"
#if (!defined PHYSFS_SUPPORTS_ZIP)
#error PHYSFS_SUPPORTS_ZIP must be defined.
#endif
35
#define MAXZIPENTRYSIZE 256
36
37
38
typedef struct
{
39
40
41
42
43
44
45
char *name;
unz_file_info info;
char *symlink;
} ZIPentry;
typedef struct
{
46
char *archiveName;
47
48
unz_global_info global;
ZIPentry *entries;
49
50
51
52
} ZIPinfo;
typedef struct
{
53
unzFile handle;
54
55
56
} ZIPfileinfo;
57
58
59
60
/* Number of symlinks to follow before we assume it's a recursive link... */
#define SYMLINK_RECURSE_COUNT 20
61
62
static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount);
63
static int ZIP_eof(FileHandle *handle);
64
65
66
static PHYSFS_sint64 ZIP_tell(FileHandle *handle);
static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset);
static PHYSFS_sint64 ZIP_fileLength(FileHandle *handle);
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
static int ZIP_fileClose(FileHandle *handle);
static int ZIP_isArchive(const char *filename, int forWriting);
static char *ZIP_realpath(unzFile fh, unz_file_info *info);
static DirHandle *ZIP_openArchive(const char *name, int forWriting);
static LinkedStringList *ZIP_enumerateFiles(DirHandle *h,
const char *dirname,
int omitSymLinks);
static int ZIP_exists(DirHandle *h, const char *name);
static int ZIP_isDirectory(DirHandle *h, const char *name);
static int ZIP_isSymLink(DirHandle *h, const char *name);
static FileHandle *ZIP_openRead(DirHandle *h, const char *filename);
static void ZIP_dirClose(DirHandle *h);
static const FileFunctions __PHYSFS_FileFunctions_ZIP =
{
ZIP_read, /* read() method */
NULL, /* write() method */
ZIP_eof, /* eof() method */
ZIP_tell, /* tell() method */
ZIP_seek, /* seek() method */
ZIP_fileLength, /* fileLength() method */
ZIP_fileClose /* fileClose() method */
};
const DirFunctions __PHYSFS_DirFunctions_ZIP =
{
ZIP_isArchive, /* isArchive() method */
ZIP_openArchive, /* openArchive() method */
ZIP_enumerateFiles, /* enumerateFiles() method */
ZIP_exists, /* exists() method */
ZIP_isDirectory, /* isDirectory() method */
ZIP_isSymLink, /* isSymLink() method */
ZIP_openRead, /* openRead() method */
NULL, /* openWrite() method */
NULL, /* openAppend() method */
NULL, /* remove() method */
NULL, /* mkdir() method */
ZIP_dirClose /* dirClose() method */
};
const PHYSFS_ArchiveInfo __PHYSFS_ArchiveInfo_ZIP =
{
"ZIP",
"PkZip/WinZip/Info-Zip compatible",
113
"Ryan C. Gordon <icculus@clutteredmind.org>",
114
115
116
117
118
"http://www.icculus.org/physfs/",
};
119
120
static PHYSFS_sint64 ZIP_read(FileHandle *handle, void *buffer,
PHYSFS_uint32 objSize, PHYSFS_uint32 objCount)
121
{
122
unzFile fh = ((ZIPfileinfo *) (handle->opaque))->handle;
123
124
int bytes = (int) (objSize * objCount); /* !!! FIXME: overflow? */
PHYSFS_sint32 rc = unzReadCurrentFile(fh, buffer, bytes);
125
126
127
128
129
130
131
132
133
if (rc < bytes)
__PHYSFS_setError(ERR_PAST_EOF);
else if (rc == UNZ_ERRNO)
__PHYSFS_setError(ERR_IO_ERROR);
else if (rc < 0)
__PHYSFS_setError(ERR_COMPRESSION);
return(rc / objSize);
134
135
136
137
138
} /* ZIP_read */
static int ZIP_eof(FileHandle *handle)
{
139
return(unzeof(((ZIPfileinfo *) (handle->opaque))->handle));
140
141
142
} /* ZIP_eof */
143
static PHYSFS_sint64 ZIP_tell(FileHandle *handle)
144
{
145
return(unztell(((ZIPfileinfo *) (handle->opaque))->handle));
146
147
148
} /* ZIP_tell */
149
static int ZIP_seek(FileHandle *handle, PHYSFS_uint64 offset)
150
{
151
/* !!! FIXME : this blows. */
152
unzFile fh = ((ZIPfileinfo *) (handle->opaque))->handle;
153
char *buf = NULL;
154
PHYSFS_uint32 bufsize = 4096 * 2;
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
BAIL_IF_MACRO(unztell(fh) == offset, NULL, 1);
BAIL_IF_MACRO(ZIP_fileLength(handle) <= offset, ERR_PAST_EOF, 0);
/* reset to the start of the zipfile. */
unzCloseCurrentFile(fh);
BAIL_IF_MACRO(unzOpenCurrentFile(fh) != UNZ_OK, ERR_IO_ERROR, 0);
while ((buf == NULL) && (bufsize >= 512))
{
bufsize >>= 1; /* divides by two. */
buf = (char *) malloc(bufsize);
} /* while */
BAIL_IF_MACRO(buf == NULL, ERR_OUT_OF_MEMORY, 0);
while (offset > 0)
{
172
173
PHYSFS_uint32 chunk = (offset > bufsize) ? bufsize : offset;
PHYSFS_sint32 rc = unzReadCurrentFile(fh, buf, chunk);
174
175
176
177
178
179
180
181
BAIL_IF_MACRO(rc == 0, ERR_IO_ERROR, 0); /* shouldn't happen. */
BAIL_IF_MACRO(rc == UNZ_ERRNO, ERR_IO_ERROR, 0);
BAIL_IF_MACRO(rc < 0, ERR_COMPRESSION, 0);
offset -= rc;
} /* while */
free(buf);
return(offset == 0);
182
183
184
} /* ZIP_seek */
185
static PHYSFS_sint64 ZIP_fileLength(FileHandle *handle)
186
{
187
188
189
190
191
ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque);
unz_file_info info;
unzGetCurrentFileInfo(finfo->handle, &info, NULL, 0, NULL, 0, NULL, 0);
return(info.uncompressed_size);
192
193
194
} /* ZIP_fileLength */
195
196
static int ZIP_fileClose(FileHandle *handle)
{
197
198
199
200
201
ZIPfileinfo *finfo = (ZIPfileinfo *) (handle->opaque);
unzClose(finfo->handle);
free(finfo);
free(handle);
return(1);
202
203
204
205
206
} /* ZIP_fileClose */
static int ZIP_isArchive(const char *filename, int forWriting)
{
207
int retval = 0;
208
unzFile unz = unzOpen(filename);
209
210
211
212
213
214
215
216
217
218
unz_global_info global;
if (unz != NULL)
{
if (unzGetGlobalInfo(unz, &global) == UNZ_OK)
retval = 1;
unzClose(unz);
} /* if */
return(retval);
219
220
221
} /* ZIP_isArchive */
222
static void freeEntries(ZIPinfo *info, int count, const char *errmsg)
223
{
224
int i;
225
226
227
228
229
230
231
for (i = 0; i < count; i++)
{
free(info->entries[i].name);
if (info->entries[i].symlink != NULL)
free(info->entries[i].symlink);
} /* for */
232
233
free(info->entries);
234
235
236
237
if (errmsg != NULL)
__PHYSFS_setError(errmsg);
} /* freeEntries */
238
239
240
241
242
243
244
245
246
/*
* !!! FIXME: Really implement this.
* !!! FIXME: symlinks in zipfiles can be relative paths, including
* !!! FIXME: "." and ".." entries. These need to be parsed out.
* !!! FIXME: For now, though, we're just copying the relative path. Oh well.
*/
static char *expand_symlink_path(const char *path, ZIPentry *entry)
247
{
248
char *retval = (char *) malloc(strlen(path) + 1);
249
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
250
strcpy(retval, path);
251
return(retval);
252
} /* expand_symlink_path */
253
254
255
static char *ZIP_realpath(unzFile fh, unz_file_info *info, ZIPentry *entry)
256
{
257
258
259
260
261
262
263
264
265
266
267
268
269
char path[MAXZIPENTRYSIZE];
int size = info->uncompressed_size;
int rc;
BAIL_IF_MACRO(size >= sizeof (path), ERR_IO_ERROR, NULL);
BAIL_IF_MACRO(unzOpenCurrentFile(fh) != UNZ_OK, ERR_IO_ERROR, NULL);
rc = unzReadCurrentFile(fh, path, size);
unzCloseCurrentFile(fh);
BAIL_IF_MACRO(rc != size, ERR_IO_ERROR, NULL);
path[size] = '\0'; /* null terminate it. */
return(expand_symlink_path(path, entry)); /* retval is malloc()'d. */
} /* ZIP_realpath */
270
271
272
273
274
static int version_does_symlinks(uLong version)
{
int retval = 0;
275
unsigned char hosttype = ((version >> 8) & 0xFF);
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
/*
* These are the platforms that can build an archive with symlinks,
* according to the Info-ZIP project.
*/
switch (hosttype)
{
case 3: /* Unix */
case 16: /* BeOS */
case 5: /* Atari */
retval = 1;
break;
} /* switch */
return(retval);
} /* version_does_symlinks */
static int entry_is_symlink(unz_file_info *info)
{
return (
(version_does_symlinks(info->version)) &&
(info->uncompressed_size > 0) &&
(info->external_fa & 0x0120000) /* symlink flag. */
);
} /* entry_is_symlink */
304
static int loadZipEntries(ZIPinfo *info, unzFile unz)
305
{
306
307
308
309
310
int i, max;
BAIL_IF_MACRO(unzGetGlobalInfo(unz, &(info->global)) != UNZ_OK,
ERR_IO_ERROR, 0);
BAIL_IF_MACRO(unzGoToFirstFile(unz) != UNZ_OK, ERR_IO_ERROR, 0);
311
312
313
314
315
316
max = info->global.number_entry;
info->entries = (ZIPentry *) malloc(sizeof (ZIPentry) * max);
BAIL_IF_MACRO(info->entries == NULL, ERR_OUT_OF_MEMORY, 0);
for (i = 0; i < max; i++)
317
{
318
319
unz_file_info *d = &((info->entries[i]).info);
if (unzGetCurrentFileInfo(unz, d, NULL, 0, NULL, 0, NULL, 0) != UNZ_OK)
320
{
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
freeEntries(info, i, ERR_IO_ERROR);
return(0);
} /* if */
(info->entries[i]).name = (char *) malloc(d->size_filename + 1);
if ((info->entries[i]).name == NULL)
{
freeEntries(info, i, ERR_OUT_OF_MEMORY);
return(0);
} /* if */
info->entries[i].symlink = NULL;
if (unzGetCurrentFileInfo(unz, NULL, (info->entries[i]).name,
d->size_filename + 1, NULL, 0,
NULL, 0) != UNZ_OK)
{
freeEntries(info, i + 1, ERR_IO_ERROR);
return(0);
} /* if */
if (entry_is_symlink(d))
{
344
info->entries[i].symlink = ZIP_realpath(unz, d, &info->entries[i]);
345
346
347
348
349
if (info->entries[i].symlink == NULL)
{
freeEntries(info, i + 1, NULL);
return(0);
} /* if */
350
} /* if */
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
if ((unzGoToNextFile(unz) != UNZ_OK) && (i + 1 < max))
{
freeEntries(info, i + 1, ERR_IO_ERROR);
return(0);
} /* if */
} /* for */
return(1);
} /* loadZipEntries */
static DirHandle *ZIP_openArchive(const char *name, int forWriting)
{
unzFile unz = NULL;
DirHandle *retval = NULL;
BAIL_IF_MACRO(forWriting, ERR_ARC_IS_READ_ONLY, NULL);
retval = malloc(sizeof (DirHandle));
BAIL_IF_MACRO(retval == NULL, ERR_OUT_OF_MEMORY, NULL);
unz = unzOpen(name);
if (unz == NULL)
{
free(retval);
BAIL_IF_MACRO(1, ERR_UNSUPPORTED_ARCHIVE, NULL);
} /* if */
retval->opaque = malloc(sizeof (ZIPinfo));
if (retval->opaque == NULL)
{
free(retval);
unzClose(unz);
BAIL_IF_MACRO(1, ERR_OUT_OF_MEMORY, NULL);
} /* if */
((ZIPinfo *) (retval->opaque))->archiveName = malloc(strlen(name) + 1);
if ( (((ZIPinfo *) (retval->opaque))->archiveName == NULL) ||
(!loadZipEntries( (ZIPinfo *) (retval->opaque), unz)) )
{
if (((ZIPinfo *) (retval->opaque))->archiveName != NULL)
free(((ZIPinfo *) (retval->opaque))->archiveName);
free(retval->opaque);
free(retval);
unzClose(unz);
BAIL_IF_MACRO(1, ERR_OUT_OF_MEMORY, NULL);
398
399
} /* if */
400
401
402
403
unzClose(unz);
strcpy(((ZIPinfo *) (retval->opaque))->archiveName, name);
retval->funcs = &__PHYSFS_DirFunctions_ZIP;
404
return(retval);
405
} /* ZIP_openArchive */
406
407
408
/* !!! This is seriously ugly. */
409
410
411
static LinkedStringList *ZIP_enumerateFiles(DirHandle *h,
const char *dirname,
int omitSymLinks)
412
{
413
ZIPinfo *zi = (ZIPinfo *) (h->opaque);
414
unsigned int i;
415
int dlen;
416
417
418
419
LinkedStringList *retval = NULL;
LinkedStringList *l = NULL;
LinkedStringList *prev = NULL;
char *d;
420
421
ZIPentry *entry;
char buf[MAXZIPENTRYSIZE];
422
423
424
425
dlen = strlen(dirname);
d = malloc(dlen + 1);
BAIL_IF_MACRO(d == NULL, ERR_OUT_OF_MEMORY, NULL);
426
strcpy(d, dirname);
427
428
429
430
431
if ((dlen > 0) && (d[dlen - 1] == '/')) /* no trailing slash. */
{
dlen--;
d[dlen] = '\0';
} /* if */
432
433
for (i = 0, entry = zi->entries; i < zi->global.number_entry; i++, entry++)
434
435
{
char *ptr;
436
437
438
char *add_file;
int this_dlen;
439
if ((omitSymLinks) && (entry->symlink != NULL))
440
441
continue;
442
443
444
445
446
447
this_dlen = strlen(entry->name);
if (this_dlen + 1 > MAXZIPENTRYSIZE)
continue; /* ugh. */
strcpy(buf, entry->name);
448
if ((this_dlen > 0) && (buf[this_dlen - 1] == '/')) /* no trailing slash. */
449
{
450
451
452
453
454
455
456
457
458
this_dlen--;
buf[this_dlen] = '\0';
} /* if */
if (this_dlen <= dlen) /* not in this dir. */
continue;
if (*d == '\0')
add_file = buf;
459
460
else
{
461
462
463
464
if (buf[dlen] != '/') /* can't be in same directory? */
continue;
buf[dlen] = '\0';
465
if (__PHYSFS_platformStricmp(d, buf) != 0) /* not same directory? */
466
467
468
continue;
add_file = buf + dlen + 1;
469
470
} /* else */
471
472
473
474
475
476
477
478
/* handle subdirectories... */
ptr = strchr(add_file, '/');
if (ptr != NULL)
{
LinkedStringList *j;
*ptr = '\0';
for (j = retval; j != NULL; j = j->next)
{
479
if (__PHYSFS_platformStricmp(j->str, ptr) == 0)
480
481
482
483
484
485
486
break;
} /* for */
if (j != NULL)
continue;
} /* if */
487
l = (LinkedStringList *) malloc(sizeof (LinkedStringList));
488
if (l == NULL)
489
490
break;
491
l->str = (char *) malloc(strlen(add_file) + 1);
492
493
494
495
496
497
if (l->str == NULL)
{
free(l);
break;
} /* if */
498
strcpy(l->str, add_file);
499
500
501
502
503
504
505
506
507
508
509
510
if (retval == NULL)
retval = l;
else
prev->next = l;
prev = l;
l->next = NULL;
} /* for */
free(d);
return(retval);
511
512
513
} /* ZIP_enumerateFiles */
514
515
516
517
518
519
520
/* !!! This is seriously ugly. */
static int ZIP_exists_symcheck(DirHandle *h, const char *name, int follow)
{
char buf[MAXZIPENTRYSIZE];
ZIPinfo *zi = (ZIPinfo *) (h->opaque);
int dlen;
char *d;
521
unsigned int i;
522
ZIPentry *entry;
523
524
525
dlen = strlen(name);
d = malloc(dlen + 1);
526
BAIL_IF_MACRO(d == NULL, ERR_OUT_OF_MEMORY, -1);
527
528
529
530
531
532
533
strcpy(d, name);
if ((dlen > 0) && (d[dlen - 1] == '/')) /* no trailing slash. */
{
dlen--;
d[dlen] = '\0';
} /* if */
534
for (i = 0, entry = zi->entries; i < zi->global.number_entry; i++, entry++)
535
{
536
537
538
539
540
int this_dlen = strlen(entry->name);
if (this_dlen + 1 > MAXZIPENTRYSIZE)
continue; /* ugh. */
strcpy(buf, entry->name);
541
542
543
544
545
546
547
548
549
if ((this_dlen > 0) && (buf[this_dlen - 1] == '/')) /* no trailing slash. */
{
this_dlen--;
buf[this_dlen] = '\0';
} /* if */
if ( ((buf[dlen] == '/') || (buf[dlen] == '\0')) &&
(strncmp(d, buf, dlen) == 0) )
{
550
int retval = i;
551
552
553
free(d);
if (follow) /* follow symlinks? */
{
554
555
if (entry->symlink != NULL)
retval = ZIP_exists_symcheck(h, entry->symlink, follow-1);
556
557
558
559
560
561
} /* if */
return(retval);
} /* if */
} /* for */
free(d);
562
return(-1);
563
564
565
} /* ZIP_exists_symcheck */
566
static int ZIP_exists(DirHandle *h, const char *name)
567
{
568
569
int retval = ZIP_exists_symcheck(h, name, SYMLINK_RECURSE_COUNT);
int is_sym;
570
571
572
if (retval == -1)
return(0);
573
574
575
576
/* if it's a symlink, then we ran into a possible symlink loop. */
is_sym = ( ((ZIPinfo *)(h->opaque))->entries[retval].symlink != NULL );
BAIL_IF_MACRO(is_sym, ERR_TOO_MANY_SYMLINKS, 0);
577
578
return(1);
579
580
581
} /* ZIP_exists */
582
static int ZIP_isDirectory(DirHandle *h, const char *name)
583
{
584
585
586
int dlen;
int is_sym;
int retval = ZIP_exists_symcheck(h, name, SYMLINK_RECURSE_COUNT);
587
588
589
590
591
592
593
if (retval == -1)
return(0);
/* if it's a symlink, then we ran into a possible symlink loop. */
is_sym = ( ((ZIPinfo *)(h->opaque))->entries[retval].symlink != NULL );
BAIL_IF_MACRO(is_sym, ERR_TOO_MANY_SYMLINKS, 0);
594
595
596
597
dlen = strlen(name);
/* !!! yikes. Better way to check? */
retval = (((ZIPinfo *)(h->opaque))->entries[retval].name[dlen] == '/');
598
return(retval);
599
600
601
} /* ZIP_isDirectory */
602
static int ZIP_isSymLink(DirHandle *h, const char *name)
603
{
604
int retval = ZIP_exists_symcheck(h, name, 0);
605
606
if (retval == -1)
return(0);
607
608
retval = ( ((ZIPinfo *)(h->opaque))->entries[retval].symlink != NULL );
609
return(retval);
610
611
612
} /* ZIP_isSymLink */
613
static FileHandle *ZIP_openRead(DirHandle *h, const char *filename)
614
{
615
FileHandle *retval = NULL;
616
ZIPinfo *zi = ((ZIPinfo *) (h->opaque));
617
ZIPfileinfo *finfo = NULL;
618
int pos = ZIP_exists_symcheck(h, filename, SYMLINK_RECURSE_COUNT);
619
unzFile f;
620
621
BAIL_IF_MACRO(pos == -1, ERR_NO_SUCH_FILE, NULL);
622
623
f = unzOpen(zi->archiveName);
624
625
BAIL_IF_MACRO(f == NULL, ERR_IO_ERROR, NULL);
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
if (unzGoToFirstFile(f) != UNZ_OK)
{
unzClose(f);
BAIL_IF_MACRO(1, ERR_IO_ERROR, NULL);
} /* if */
for (; pos > 0; pos--)
{
if (unzGoToNextFile(f) != UNZ_OK)
{
unzClose(f);
BAIL_IF_MACRO(1, ERR_IO_ERROR, NULL);
} /* if */
} /* for */
if ( (unzOpenCurrentFile(f) != UNZ_OK) ||
642
( (finfo = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo))) == NULL ) )
643
644
645
646
647
{
unzClose(f);
BAIL_IF_MACRO(1, ERR_IO_ERROR, NULL);
} /* if */
648
649
650
651
652
653
654
655
656
if ( (!(retval = (FileHandle *) malloc(sizeof (FileHandle)))) ||
(!(retval->opaque = (ZIPfileinfo *) malloc(sizeof (ZIPfileinfo)))) )
{
if (retval)
free(retval);
unzClose(f);
BAIL_IF_MACRO(1, ERR_OUT_OF_MEMORY, NULL);
} /* if */
657
finfo->handle = f;
658
retval->opaque = (void *) finfo;
659
retval->funcs = &__PHYSFS_FileFunctions_ZIP;
660
661
retval->dirHandle = h;
return(retval);
662
663
664
} /* ZIP_openRead */
665
static void ZIP_dirClose(DirHandle *h)
666
{
667
668
669
670
ZIPinfo *zi = (ZIPinfo *) (h->opaque);
freeEntries(zi, zi->global.number_entry, NULL);
free(zi->archiveName);
free(zi);
671
free(h);
672
673
} /* ZIP_dirClose */
674
/* end of zip.c ... */