Merge from vendor branch TNFTP:
[dragonfly.git] / contrib / libarchive-2 / libarchive / archive_read_support_format_zip.c
1 /*-
2  * Copyright (c) 2004 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_support_format_zip.c,v 1.16 2007/12/04 06:32:12 kientzle Exp $");
28
29 #ifdef HAVE_ERRNO_H
30 #include <errno.h>
31 #endif
32 #include <stdio.h>
33 #ifdef HAVE_STDLIB_H
34 #include <stdlib.h>
35 #endif
36 #include <time.h>
37 #ifdef HAVE_ZLIB_H
38 #include <zlib.h>
39 #endif
40
41 #include "archive.h"
42 #include "archive_entry.h"
43 #include "archive_private.h"
44 #include "archive_read_private.h"
45
46 struct zip {
47         /* entry_bytes_remaining is the number of bytes we expect. */
48         int64_t                 entry_bytes_remaining;
49         int64_t                 entry_offset;
50
51         /* These count the number of bytes actually read for the entry. */
52         int64_t                 entry_compressed_bytes_read;
53         int64_t                 entry_uncompressed_bytes_read;
54
55         unsigned                version;
56         unsigned                system;
57         unsigned                flags;
58         unsigned                compression;
59         const char *            compression_name;
60         time_t                  mtime;
61         time_t                  ctime;
62         time_t                  atime;
63         mode_t                  mode;
64         uid_t                   uid;
65         gid_t                   gid;
66
67         /* Flags to mark progress of decompression. */
68         char                    decompress_init;
69         char                    end_of_entry;
70         char                    end_of_entry_cleanup;
71
72         long                    crc32;
73         ssize_t                 filename_length;
74         ssize_t                 extra_length;
75         int64_t                 uncompressed_size;
76         int64_t                 compressed_size;
77
78         unsigned char           *uncompressed_buffer;
79         size_t                  uncompressed_buffer_size;
80 #ifdef HAVE_ZLIB_H
81         z_stream                stream;
82         char                    stream_valid;
83 #endif
84
85         struct archive_string   pathname;
86         struct archive_string   extra;
87         char    format_name[64];
88 };
89
90 #define ZIP_LENGTH_AT_END       8
91
92 struct zip_file_header {
93         char    signature[4];
94         char    version[2];
95         char    flags[2];
96         char    compression[2];
97         char    timedate[4];
98         char    crc32[4];
99         char    compressed_size[4];
100         char    uncompressed_size[4];
101         char    filename_length[2];
102         char    extra_length[2];
103 };
104
105 static const char *compression_names[] = {
106         "uncompressed",
107         "shrinking",
108         "reduced-1",
109         "reduced-2",
110         "reduced-3",
111         "reduced-4",
112         "imploded",
113         "reserved",
114         "deflation"
115 };
116
117 static int      archive_read_format_zip_bid(struct archive_read *);
118 static int      archive_read_format_zip_cleanup(struct archive_read *);
119 static int      archive_read_format_zip_read_data(struct archive_read *,
120                     const void **, size_t *, off_t *);
121 static int      archive_read_format_zip_read_data_skip(struct archive_read *a);
122 static int      archive_read_format_zip_read_header(struct archive_read *,
123                     struct archive_entry *);
124 static int      i2(const char *);
125 static int      i4(const char *);
126 static unsigned int     u2(const char *);
127 static unsigned int     u4(const char *);
128 static uint64_t u8(const char *);
129 static int      zip_read_data_deflate(struct archive_read *a, const void **buff,
130                     size_t *size, off_t *offset);
131 static int      zip_read_data_none(struct archive_read *a, const void **buff,
132                     size_t *size, off_t *offset);
133 static int      zip_read_file_header(struct archive_read *a,
134                     struct archive_entry *entry, struct zip *zip);
135 static time_t   zip_time(const char *);
136 static void process_extra(const void* extra, struct zip* zip);
137
138 int
139 archive_read_support_format_zip(struct archive *_a)
140 {
141         struct archive_read *a = (struct archive_read *)_a;
142         struct zip *zip;
143         int r;
144
145         zip = (struct zip *)malloc(sizeof(*zip));
146         if (zip == NULL) {
147                 archive_set_error(&a->archive, ENOMEM, "Can't allocate zip data");
148                 return (ARCHIVE_FATAL);
149         }
150         memset(zip, 0, sizeof(*zip));
151
152         r = __archive_read_register_format(a,
153             zip,
154             archive_read_format_zip_bid,
155             archive_read_format_zip_read_header,
156             archive_read_format_zip_read_data,
157             archive_read_format_zip_read_data_skip,
158             archive_read_format_zip_cleanup);
159
160         if (r != ARCHIVE_OK)
161                 free(zip);
162         return (ARCHIVE_OK);
163 }
164
165
166 static int
167 archive_read_format_zip_bid(struct archive_read *a)
168 {
169         int bytes_read;
170         int bid = 0;
171         const void *h;
172         const char *p;
173
174         if (a->archive.archive_format == ARCHIVE_FORMAT_ZIP)
175                 bid += 1;
176
177         bytes_read = (a->decompressor->read_ahead)(a, &h, 4);
178         if (bytes_read < 4)
179             return (-1);
180         p = (const char *)h;
181
182         /*
183          * Bid of 30 here is: 16 bits for "PK",
184          * next 16-bit field has four options (-2 bits).
185          * 16 + 16-2 = 30.
186          */
187         if (p[0] == 'P' && p[1] == 'K') {
188                 if ((p[2] == '\001' && p[3] == '\002')
189                     || (p[2] == '\003' && p[3] == '\004')
190                     || (p[2] == '\005' && p[3] == '\006')
191                     || (p[2] == '\007' && p[3] == '\010'))
192                         return (30);
193         }
194         return (0);
195 }
196
197 static int
198 archive_read_format_zip_read_header(struct archive_read *a,
199     struct archive_entry *entry)
200 {
201         int bytes_read;
202         const void *h;
203         const char *signature;
204         struct zip *zip;
205
206         a->archive.archive_format = ARCHIVE_FORMAT_ZIP;
207         if (a->archive.archive_format_name == NULL)
208                 a->archive.archive_format_name = "ZIP";
209
210         zip = (struct zip *)(a->format->data);
211         zip->decompress_init = 0;
212         zip->end_of_entry = 0;
213         zip->end_of_entry_cleanup = 0;
214         zip->entry_uncompressed_bytes_read = 0;
215         zip->entry_compressed_bytes_read = 0;
216         bytes_read = (a->decompressor->read_ahead)(a, &h, 4);
217         if (bytes_read < 4)
218                 return (ARCHIVE_FATAL);
219
220         signature = (const char *)h;
221         if (signature[0] != 'P' || signature[1] != 'K') {
222                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
223                     "Bad ZIP file");
224                 return (ARCHIVE_FATAL);
225         }
226
227         if (signature[2] == '\001' && signature[3] == '\002') {
228                 /* Beginning of central directory. */
229                 return (ARCHIVE_EOF);
230         }
231
232         if (signature[2] == '\003' && signature[3] == '\004') {
233                 /* Regular file entry. */
234                 return (zip_read_file_header(a, entry, zip));
235         }
236
237         if (signature[2] == '\005' && signature[3] == '\006') {
238                 /* End-of-archive record. */
239                 return (ARCHIVE_EOF);
240         }
241
242         if (signature[2] == '\007' && signature[3] == '\010') {
243                 /*
244                  * We should never encounter this record here;
245                  * see ZIP_LENGTH_AT_END handling below for details.
246                  */
247                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
248                     "Bad ZIP file: Unexpected end-of-entry record");
249                 return (ARCHIVE_FATAL);
250         }
251
252         archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
253             "Damaged ZIP file or unsupported format variant (%d,%d)",
254             signature[2], signature[3]);
255         return (ARCHIVE_FATAL);
256 }
257
258 int
259 zip_read_file_header(struct archive_read *a, struct archive_entry *entry,
260     struct zip *zip)
261 {
262         const struct zip_file_header *p;
263         const void *h;
264         int bytes_read;
265
266         bytes_read =
267             (a->decompressor->read_ahead)(a, &h, sizeof(struct zip_file_header));
268         if (bytes_read < (int)sizeof(struct zip_file_header)) {
269                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
270                     "Truncated ZIP file header");
271                 return (ARCHIVE_FATAL);
272         }
273         p = (const struct zip_file_header *)h;
274
275         zip->version = p->version[0];
276         zip->system = p->version[1];
277         zip->flags = i2(p->flags);
278         zip->compression = i2(p->compression);
279         if (zip->compression <
280             sizeof(compression_names)/sizeof(compression_names[0]))
281                 zip->compression_name = compression_names[zip->compression];
282         else
283                 zip->compression_name = "??";
284         zip->mtime = zip_time(p->timedate);
285         zip->ctime = 0;
286         zip->atime = 0;
287         zip->mode = 0;
288         zip->uid = 0;
289         zip->gid = 0;
290         zip->crc32 = i4(p->crc32);
291         zip->filename_length = i2(p->filename_length);
292         zip->extra_length = i2(p->extra_length);
293         zip->uncompressed_size = u4(p->uncompressed_size);
294         zip->compressed_size = u4(p->compressed_size);
295
296         (a->decompressor->consume)(a, sizeof(struct zip_file_header));
297
298
299         /* Read the filename. */
300         bytes_read = (a->decompressor->read_ahead)(a, &h, zip->filename_length);
301         if (bytes_read < zip->filename_length) {
302                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
303                     "Truncated ZIP file header");
304                 return (ARCHIVE_FATAL);
305         }
306         if (archive_string_ensure(&zip->pathname, zip->filename_length) == NULL)
307                 __archive_errx(1, "Out of memory");
308         archive_strncpy(&zip->pathname, (const char *)h, zip->filename_length);
309         (a->decompressor->consume)(a, zip->filename_length);
310         archive_entry_set_pathname(entry, zip->pathname.s);
311
312         if (zip->pathname.s[archive_strlen(&zip->pathname) - 1] == '/')
313                 zip->mode = AE_IFDIR | 0777;
314         else
315                 zip->mode = AE_IFREG | 0777;
316
317         /* Read the extra data. */
318         bytes_read = (a->decompressor->read_ahead)(a, &h, zip->extra_length);
319         if (bytes_read < zip->extra_length) {
320                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
321                     "Truncated ZIP file header");
322                 return (ARCHIVE_FATAL);
323         }
324         process_extra(h, zip);
325         (a->decompressor->consume)(a, zip->extra_length);
326
327         /* Populate some additional entry fields: */
328         archive_entry_set_mode(entry, zip->mode);
329         archive_entry_set_uid(entry, zip->uid);
330         archive_entry_set_gid(entry, zip->gid);
331         archive_entry_set_mtime(entry, zip->mtime, 0);
332         archive_entry_set_ctime(entry, zip->ctime, 0);
333         archive_entry_set_atime(entry, zip->atime, 0);
334         archive_entry_set_size(entry, zip->uncompressed_size);
335
336         zip->entry_bytes_remaining = zip->compressed_size;
337         zip->entry_offset = 0;
338
339         /* If there's no body, force read_data() to return EOF immediately. */
340         if (0 == (zip->flags & ZIP_LENGTH_AT_END)
341             && zip->entry_bytes_remaining < 1)
342                 zip->end_of_entry = 1;
343
344         /* Set up a more descriptive format name. */
345         sprintf(zip->format_name, "ZIP %d.%d (%s)",
346             zip->version / 10, zip->version % 10,
347             zip->compression_name);
348         a->archive.archive_format_name = zip->format_name;
349
350         return (ARCHIVE_OK);
351 }
352
353 /* Convert an MSDOS-style date/time into Unix-style time. */
354 static time_t
355 zip_time(const char *p)
356 {
357         int msTime, msDate;
358         struct tm ts;
359
360         msTime = (0xff & (unsigned)p[0]) + 256 * (0xff & (unsigned)p[1]);
361         msDate = (0xff & (unsigned)p[2]) + 256 * (0xff & (unsigned)p[3]);
362
363         memset(&ts, 0, sizeof(ts));
364         ts.tm_year = ((msDate >> 9) & 0x7f) + 80; /* Years since 1900. */
365         ts.tm_mon = ((msDate >> 5) & 0x0f) - 1; /* Month number. */
366         ts.tm_mday = msDate & 0x1f; /* Day of month. */
367         ts.tm_hour = (msTime >> 11) & 0x1f;
368         ts.tm_min = (msTime >> 5) & 0x3f;
369         ts.tm_sec = (msTime << 1) & 0x3e;
370         ts.tm_isdst = -1;
371         return mktime(&ts);
372 }
373
374 static int
375 archive_read_format_zip_read_data(struct archive_read *a,
376     const void **buff, size_t *size, off_t *offset)
377 {
378         int r;
379         struct zip *zip;
380
381         zip = (struct zip *)(a->format->data);
382
383         /*
384          * If we hit end-of-entry last time, clean up and return
385          * ARCHIVE_EOF this time.
386          */
387         if (zip->end_of_entry) {
388                 if (!zip->end_of_entry_cleanup) {
389                         if (zip->flags & ZIP_LENGTH_AT_END) {
390                                 const void *h;
391                                 const char *p;
392                                 int bytes_read =
393                                     (a->decompressor->read_ahead)(a, &h, 16);
394                                 if (bytes_read < 16) {
395                                         archive_set_error(&a->archive,
396                                             ARCHIVE_ERRNO_FILE_FORMAT,
397                                             "Truncated ZIP end-of-file record");
398                                         return (ARCHIVE_FATAL);
399                                 }
400                                 p = (const char *)h;
401                                 zip->crc32 = i4(p + 4);
402                                 zip->compressed_size = u4(p + 8);
403                                 zip->uncompressed_size = u4(p + 12);
404                                 bytes_read = (a->decompressor->consume)(a, 16);
405                         }
406
407                         /* Check file size, CRC against these values. */
408                         if (zip->compressed_size != zip->entry_compressed_bytes_read) {
409                                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
410                                     "ZIP compressed data is wrong size");
411                                 return (ARCHIVE_WARN);
412                         }
413                         /* Size field only stores the lower 32 bits of the actual size. */
414                         if ((zip->uncompressed_size & UINT32_MAX)
415                             != (zip->entry_uncompressed_bytes_read & UINT32_MAX)) {
416                                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
417                                     "ZIP uncompressed data is wrong size");
418                                 return (ARCHIVE_WARN);
419                         }
420 /* TODO: Compute CRC. */
421 /*
422                         if (zip->crc32 != zip->entry_crc32_calculated) {
423                                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
424                                     "ZIP data CRC error");
425                                 return (ARCHIVE_WARN);
426                         }
427 */
428                         /* End-of-entry cleanup done. */
429                         zip->end_of_entry_cleanup = 1;
430                 }
431                 *offset = zip->entry_uncompressed_bytes_read;
432                 *size = 0;
433                 *buff = NULL;
434                 return (ARCHIVE_EOF);
435         }
436
437         switch(zip->compression) {
438         case 0:  /* No compression. */
439                 r =  zip_read_data_none(a, buff, size, offset);
440                 break;
441         case 8: /* Deflate compression. */
442                 r =  zip_read_data_deflate(a, buff, size, offset);
443                 break;
444         default: /* Unsupported compression. */
445                 *buff = NULL;
446                 *size = 0;
447                 *offset = 0;
448                 /* Return a warning. */
449                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
450                     "Unsupported ZIP compression method (%s)",
451                     zip->compression_name);
452                 if (zip->flags & ZIP_LENGTH_AT_END) {
453                         /*
454                          * ZIP_LENGTH_AT_END requires us to
455                          * decompress the entry in order to
456                          * skip it, but we don't know this
457                          * compression method, so we give up.
458                          */
459                         r = ARCHIVE_FATAL;
460                 } else {
461                         /* We know compressed size; just skip it. */
462                         archive_read_format_zip_read_data_skip(a);
463                         r = ARCHIVE_WARN;
464                 }
465                 break;
466         }
467         return (r);
468 }
469
470 /*
471  * Read "uncompressed" data.  According to the current specification,
472  * if ZIP_LENGTH_AT_END is specified, then the size fields in the
473  * initial file header are supposed to be set to zero.  This would, of
474  * course, make it impossible for us to read the archive, since we
475  * couldn't determine the end of the file data.  Info-ZIP seems to
476  * include the real size fields both before and after the data in this
477  * case (the CRC only appears afterwards), so this works as you would
478  * expect.
479  *
480  * Returns ARCHIVE_OK if successful, ARCHIVE_FATAL otherwise, sets
481  * zip->end_of_entry if it consumes all of the data.
482  */
483 static int
484 zip_read_data_none(struct archive_read *a, const void **buff,
485     size_t *size, off_t *offset)
486 {
487         struct zip *zip;
488         ssize_t bytes_avail;
489
490         zip = (struct zip *)(a->format->data);
491
492         if (zip->entry_bytes_remaining == 0) {
493                 *buff = NULL;
494                 *size = 0;
495                 *offset = zip->entry_offset;
496                 zip->end_of_entry = 1;
497                 return (ARCHIVE_OK);
498         }
499         /*
500          * Note: '1' here is a performance optimization.
501          * Recall that the decompression layer returns a count of
502          * available bytes; asking for more than that forces the
503          * decompressor to combine reads by copying data.
504          */
505         bytes_avail = (a->decompressor->read_ahead)(a, buff, 1);
506         if (bytes_avail <= 0) {
507                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
508                     "Truncated ZIP file data");
509                 return (ARCHIVE_FATAL);
510         }
511         if (bytes_avail > zip->entry_bytes_remaining)
512                 bytes_avail = zip->entry_bytes_remaining;
513         (a->decompressor->consume)(a, bytes_avail);
514         *size = bytes_avail;
515         *offset = zip->entry_offset;
516         zip->entry_offset += *size;
517         zip->entry_bytes_remaining -= *size;
518         zip->entry_uncompressed_bytes_read += *size;
519         zip->entry_compressed_bytes_read += *size;
520         return (ARCHIVE_OK);
521 }
522
523 #ifdef HAVE_ZLIB_H
524 static int
525 zip_read_data_deflate(struct archive_read *a, const void **buff,
526     size_t *size, off_t *offset)
527 {
528         struct zip *zip;
529         ssize_t bytes_avail;
530         const void *compressed_buff;
531         int r;
532
533         zip = (struct zip *)(a->format->data);
534
535         /* If the buffer hasn't been allocated, allocate it now. */
536         if (zip->uncompressed_buffer == NULL) {
537                 zip->uncompressed_buffer_size = 32 * 1024;
538                 zip->uncompressed_buffer
539                     = (unsigned char *)malloc(zip->uncompressed_buffer_size);
540                 if (zip->uncompressed_buffer == NULL) {
541                         archive_set_error(&a->archive, ENOMEM,
542                             "No memory for ZIP decompression");
543                         return (ARCHIVE_FATAL);
544                 }
545         }
546
547         /* If we haven't yet read any data, initialize the decompressor. */
548         if (!zip->decompress_init) {
549                 if (zip->stream_valid)
550                         r = inflateReset(&zip->stream);
551                 else
552                         r = inflateInit2(&zip->stream,
553                             -15 /* Don't check for zlib header */);
554                 if (r != Z_OK) {
555                         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
556                             "Can't initialize ZIP decompression.");
557                         return (ARCHIVE_FATAL);
558                 }
559                 /* Stream structure has been set up. */
560                 zip->stream_valid = 1;
561                 /* We've initialized decompression for this stream. */
562                 zip->decompress_init = 1;
563         }
564
565         /*
566          * Note: '1' here is a performance optimization.
567          * Recall that the decompression layer returns a count of
568          * available bytes; asking for more than that forces the
569          * decompressor to combine reads by copying data.
570          */
571         bytes_avail = (a->decompressor->read_ahead)(a, &compressed_buff, 1);
572         if (bytes_avail <= 0) {
573                 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
574                     "Truncated ZIP file body");
575                 return (ARCHIVE_FATAL);
576         }
577
578         /*
579          * A bug in zlib.h: stream.next_in should be marked 'const'
580          * but isn't (the library never alters data through the
581          * next_in pointer, only reads it).  The result: this ugly
582          * cast to remove 'const'.
583          */
584         zip->stream.next_in = (Bytef *)(uintptr_t)(const void *)compressed_buff;
585         zip->stream.avail_in = bytes_avail;
586         zip->stream.total_in = 0;
587         zip->stream.next_out = zip->uncompressed_buffer;
588         zip->stream.avail_out = zip->uncompressed_buffer_size;
589         zip->stream.total_out = 0;
590
591         r = inflate(&zip->stream, 0);
592         switch (r) {
593         case Z_OK:
594                 break;
595         case Z_STREAM_END:
596                 zip->end_of_entry = 1;
597                 break;
598         case Z_MEM_ERROR:
599                 archive_set_error(&a->archive, ENOMEM,
600                     "Out of memory for ZIP decompression");
601                 return (ARCHIVE_FATAL);
602         default:
603                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
604                     "ZIP decompression failed (%d)", r);
605                 return (ARCHIVE_FATAL);
606         }
607
608         /* Consume as much as the compressor actually used. */
609         bytes_avail = zip->stream.total_in;
610         (a->decompressor->consume)(a, bytes_avail);
611         zip->entry_bytes_remaining -= bytes_avail;
612         zip->entry_compressed_bytes_read += bytes_avail;
613
614         *offset = zip->entry_offset;
615         *size = zip->stream.total_out;
616         zip->entry_uncompressed_bytes_read += *size;
617         *buff = zip->uncompressed_buffer;
618         zip->entry_offset += *size;
619         return (ARCHIVE_OK);
620 }
621 #else
622 static int
623 zip_read_data_deflate(struct archive_read *a, const void **buff,
624     size_t *size, off_t *offset)
625 {
626         *buff = NULL;
627         *size = 0;
628         *offset = 0;
629         archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
630             "libarchive compiled without deflate support (no libz)");
631         return (ARCHIVE_FATAL);
632 }
633 #endif
634
635 static int
636 archive_read_format_zip_read_data_skip(struct archive_read *a)
637 {
638         struct zip *zip;
639         const void *buff = NULL;
640         ssize_t bytes_avail;
641
642         zip = (struct zip *)(a->format->data);
643
644         /*
645          * If the length is at the end, we have no choice but
646          * to decompress all the data to find the end marker.
647          */
648         if (zip->flags & ZIP_LENGTH_AT_END) {
649                 size_t size;
650                 off_t offset;
651                 int r;
652                 do {
653                         r = archive_read_format_zip_read_data(a, &buff,
654                             &size, &offset);
655                 } while (r == ARCHIVE_OK);
656                 return (r);
657         }
658
659         /*
660          * If the length is at the beginning, we can skip the
661          * compressed data much more quickly.
662          */
663         while (zip->entry_bytes_remaining > 0) {
664                 bytes_avail = (a->decompressor->read_ahead)(a, &buff, 1);
665                 if (bytes_avail <= 0) {
666                         archive_set_error(&a->archive,
667                             ARCHIVE_ERRNO_FILE_FORMAT,
668                             "Truncated ZIP file body");
669                         return (ARCHIVE_FATAL);
670                 }
671                 if (bytes_avail > zip->entry_bytes_remaining)
672                         bytes_avail = zip->entry_bytes_remaining;
673                 (a->decompressor->consume)(a, bytes_avail);
674                 zip->entry_bytes_remaining -= bytes_avail;
675         }
676         /* This entry is finished and done. */
677         zip->end_of_entry_cleanup = zip->end_of_entry = 1;
678         return (ARCHIVE_OK);
679 }
680
681 static int
682 archive_read_format_zip_cleanup(struct archive_read *a)
683 {
684         struct zip *zip;
685
686         zip = (struct zip *)(a->format->data);
687 #ifdef HAVE_ZLIB_H
688         if (zip->stream_valid)
689                 inflateEnd(&zip->stream);
690 #endif
691         free(zip->uncompressed_buffer);
692         archive_string_free(&(zip->pathname));
693         archive_string_free(&(zip->extra));
694         free(zip);
695         (a->format->data) = NULL;
696         return (ARCHIVE_OK);
697 }
698
699 static int
700 i2(const char *p)
701 {
702         return ((0xff & (int)p[0]) + 256 * (0xff & (int)p[1]));
703 }
704
705
706 static int
707 i4(const char *p)
708 {
709         return ((0xffff & i2(p)) + 0x10000 * (0xffff & i2(p+2)));
710 }
711
712 static unsigned int
713 u2(const char *p)
714 {
715         return ((0xff & (unsigned int)p[0]) + 256 * (0xff & (unsigned int)p[1]));
716 }
717
718 static unsigned int
719 u4(const char *p)
720 {
721         return u2(p) + 0x10000 * u2(p+2);
722 }
723
724 static uint64_t
725 u8(const char *p)
726 {
727         return u4(p) + 0x100000000LL * u4(p+4);
728 }
729
730 /*
731  * The extra data is stored as a list of
732  *      id1+size1+data1 + id2+size2+data2 ...
733  *  triplets.  id and size are 2 bytes each.
734  */
735 static void
736 process_extra(const void* extra, struct zip* zip)
737 {
738         int offset = 0;
739         const char *p = (const char *)extra;
740         while (offset < zip->extra_length - 4)
741         {
742                 unsigned short headerid = u2(p + offset);
743                 unsigned short datasize = u2(p + offset + 2);
744                 offset += 4;
745                 if (offset + datasize > zip->extra_length)
746                         break;
747 #ifdef DEBUG
748                 fprintf(stderr, "Header id 0x%04x, length %d\n",
749                     headerid, datasize);
750 #endif
751                 switch (headerid) {
752                 case 0x0001:
753                         /* Zip64 extended information extra field. */
754                         if (datasize >= 8)
755                                 zip->uncompressed_size = u8(p + offset);
756                         if (datasize >= 16)
757                                 zip->compressed_size = u8(p + offset + 8);
758                         break;
759                 case 0x5455:
760                 {
761                         /* Extended time field "UT". */
762                         int flags = p[offset];
763                         offset++;
764                         datasize--;
765                         /* Flag bits indicate which dates are present. */
766                         if (flags & 0x01)
767                         {
768 #ifdef DEBUG
769                                 fprintf(stderr, "mtime: %lld -> %d\n",
770                                     (long long)zip->mtime, i4(p + offset));
771 #endif
772                                 if (datasize < 4)
773                                         break;
774                                 zip->mtime = i4(p + offset);
775                                 offset += 4;
776                                 datasize -= 4;
777                         }
778                         if (flags & 0x02)
779                         {
780                                 if (datasize < 4)
781                                         break;
782                                 zip->atime = i4(p + offset);
783                                 offset += 4;
784                                 datasize -= 4;
785                         }
786                         if (flags & 0x04)
787                         {
788                                 if (datasize < 4)
789                                         break;
790                                 zip->ctime = i4(p + offset);
791                                 offset += 4;
792                                 datasize -= 4;
793                         }
794                         break;
795                 }
796                 case 0x7855:
797                         /* Info-ZIP Unix Extra Field (type 2) "Ux". */
798 #ifdef DEBUG
799                         fprintf(stderr, "uid %d gid %d\n",
800                             i2(p + offset), i2(p + offset + 2));
801 #endif
802                         if (datasize >= 2)
803                                 zip->uid = i2(p + offset);
804                         if (datasize >= 4)
805                                 zip->gid = i2(p + offset + 2);
806                         break;
807                 default:
808                         break;
809                 }
810                 offset += datasize;
811         }
812 #ifdef DEBUG
813         if (offset != zip->extra_length)
814         {
815                 fprintf(stderr,
816                     "Extra data field contents do not match reported size!");
817         }
818 #endif
819 }