Mercurial > code

comparison modules/zip/libzip/lib/zip_open.c @ 527:8f8c32f102f1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Zip: resurrection
author David Demelier <markand@malikania.fr>
date Wed, 01 Jun 2016 17:36:52 +0200
parents
children
comparison
equal deleted inserted replaced
526:b26d8be94adb 527:8f8c32f102f1
1 /*
2 zip_open.c -- open zip archive by name
3 Copyright (C) 1999-2015 Dieter Baron and Thomas Klausner
4
5 This file is part of libzip, a library to manipulate ZIP archives.
6 The authors can be contacted at <libzip@nih.at>
7
8 Redistribution and use in source and binary forms, with or without
9 modification, are permitted provided that the following conditions
10 are met:
11 1. Redistributions of source code must retain the above copyright
12 notice, this list of conditions and the following disclaimer.
13 2. Redistributions in binary form must reproduce the above copyright
14 notice, this list of conditions and the following disclaimer in
15 the documentation and/or other materials provided with the
16 distribution.
17 3. The names of the authors may not be used to endorse or promote
18 products derived from this software without specific prior
19 written permission.
20
21 THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
22 OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
27 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
29 IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
31 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34
35 #include <sys/stat.h>
36 #include <limits.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <string.h>
40
41 #include "zipint.h"
42
43 typedef enum {
44 EXISTS_ERROR = -1,
45 EXISTS_NOT = 0,
46 EXISTS_EMPTY,
47 EXISTS_NONEMPTY,
48 } exists_t;
49 static zip_t *_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error);
50 static zip_int64_t _zip_checkcons(zip_t *za, zip_cdir_t *cdir, zip_error_t *error);
51 static zip_cdir_t *_zip_find_central_dir(zip_t *za, zip_uint64_t len);
52 static exists_t _zip_file_exists(zip_source_t *src, zip_error_t *error);
53 static int _zip_headercomp(const zip_dirent_t *, const zip_dirent_t *);
54 static unsigned char *_zip_memmem(const unsigned char *, size_t, const unsigned char *, size_t);
55 static zip_cdir_t *_zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error);
56 static zip_cdir_t *_zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error);
57 static zip_cdir_t *_zip_read_eocd64(zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error);
58
59
60 ZIP_EXTERN zip_t *
61 zip_open(const char *fn, int _flags, int *zep)
62 {
63 zip_t *za;
64 zip_source_t *src;
65 struct zip_error error;
66
67 zip_error_init(&error);
68 if ((src = zip_source_file_create(fn, 0, -1, &error)) == NULL) {
69 _zip_set_open_error(zep, &error, 0);
70 zip_error_fini(&error);
71 return NULL;
72 }
73
74 if ((za = zip_open_from_source(src, _flags, &error)) == NULL) {
75 zip_source_free(src);
76 _zip_set_open_error(zep, &error, 0);
77 zip_error_fini(&error);
78 return NULL;
79 }
80
81 zip_error_fini(&error);
82 return za;
83 }
84
85
86 ZIP_EXTERN zip_t *
87 zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error)
88 {
89 static zip_int64_t needed_support_read = -1;
90 static zip_int64_t needed_support_write = -1;
91
92 unsigned int flags;
93 zip_int64_t supported;
94 exists_t exists;
95
96 if (_flags < 0 || src == NULL) {
97 zip_error_set(error, ZIP_ER_INVAL, 0);
98 return NULL;
99 }
100 flags = (unsigned int)_flags;
101
102 supported = zip_source_supports(src);
103 if (needed_support_read == -1) {
104 needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);
105 needed_support_write = zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, -1);
106 }
107 if ((supported & needed_support_read) != needed_support_read) {
108 zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
109 return NULL;
110 }
111 if ((supported & needed_support_write) != needed_support_write) {
112 flags |= ZIP_RDONLY;
113 }
114
115 if ((flags & (ZIP_RDONLY|ZIP_TRUNCATE)) == (ZIP_RDONLY|ZIP_TRUNCATE)) {
116 zip_error_set(error, ZIP_ER_RDONLY, 0);
117 return NULL;
118 }
119
120 exists = _zip_file_exists(src, error);
121 switch (exists) {
122 case EXISTS_ERROR:
123 return NULL;
124
125 case EXISTS_NOT:
126 if ((flags & ZIP_CREATE) == 0) {
127 zip_error_set(error, ZIP_ER_NOENT, 0);
128 return NULL;
129 }
130 return _zip_allocate_new(src, flags, error);
131
132 default: {
133 zip_t *za;
134 if (flags & ZIP_EXCL) {
135 zip_error_set(error, ZIP_ER_EXISTS, 0);
136 return NULL;
137 }
138 if (zip_source_open(src) < 0) {
139 _zip_error_set_from_source(error, src);
140 return NULL;
141 }
142
143 if (flags & ZIP_TRUNCATE) {
144 za = _zip_allocate_new(src, flags, error);
145 }
146 else {
147 /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
148 za = _zip_open(src, flags, error);
149 }
150
151 if (za == NULL) {
152 zip_source_close(src);
153 return NULL;
154 }
155 return za;
156 }
157 }
158 }
159
160 ZIP_EXTERN int
161 zip_archive_set_tempdir(zip_t *za, const char *tempdir)
162 {
163 char *new_tempdir;
164
165 if (tempdir) {
166 if ((new_tempdir = strdup(tempdir)) == NULL) {
167 zip_error_set(&za->error, ZIP_ER_MEMORY, errno);
168 return -1;
169 }
170 }
171 else
172 new_tempdir = NULL;
173
174 free(za->tempdir);
175 za->tempdir = new_tempdir;
176
177 return 0;
178 }
179
180 zip_t *
181 _zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error)
182 {
183 zip_t *za;
184 zip_cdir_t *cdir;
185 struct zip_stat st;
186 zip_uint64_t len, idx;
187
188 zip_stat_init(&st);
189 if (zip_source_stat(src, &st) < 0) {
190 _zip_error_set_from_source(error, src);
191 return NULL;
192 }
193 if ((st.valid & ZIP_STAT_SIZE) == 0) {
194 zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
195 return NULL;
196 }
197 len = st.size;
198
199 /* treat empty files as empty archives */
200 if (len == 0) {
201 if ((za=_zip_allocate_new(src, flags, error)) == NULL) {
202 zip_source_free(src);
203 return NULL;
204 }
205
206 return za;
207 }
208
209 if ((za=_zip_allocate_new(src, flags, error)) == NULL) {
210 return NULL;
211 }
212
213 if ((cdir = _zip_find_central_dir(za, len)) == NULL) {
214 _zip_error_copy(error, &za->error);
215 /* keep src so discard does not get rid of it */
216 zip_source_keep(src);
217 zip_discard(za);
218 return NULL;
219 }
220
221 za->entry = cdir->entry;
222 za->nentry = cdir->nentry;
223 za->nentry_alloc = cdir->nentry_alloc;
224 za->comment_orig = cdir->comment;
225
226 free(cdir);
227
228 for (idx = 0; idx < za->nentry; idx++) {
229 const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
230 if (name == NULL) {
231 /* keep src so discard does not get rid of it */
232 zip_source_keep(src);
233 zip_discard(za);
234 return NULL;
235 }
236
237 if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) {
238 if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) {
239 _zip_error_copy(error, &za->error);
240 /* keep src so discard does not get rid of it */
241 zip_source_keep(src);
242 zip_discard(za);
243 return NULL;
244 }
245 }
246 }
247
248 za->ch_flags = za->flags;
249
250 return za;
251 }
252
253
254 void
255 _zip_set_open_error(int *zep, const zip_error_t *err, int ze)
256 {
257 if (err) {
258 ze = zip_error_code_zip(err);
259 if (zip_error_system_type(err) == ZIP_ET_SYS) {
260 errno = zip_error_code_system(err);
261 }
262 }
263
264 if (zep)
265 *zep = ze;
266 }
267
268
269 /* _zip_readcdir:
270 tries to find a valid end-of-central-directory at the beginning of
271 buf, and then the corresponding central directory entries.
272 Returns a struct zip_cdir which contains the central directory
273 entries, or NULL if unsuccessful. */
274
275 static zip_cdir_t *
276 _zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error)
277 {
278 zip_cdir_t *cd;
279 zip_uint16_t comment_len;
280 zip_uint64_t i, left;
281 zip_uint64_t eocd_offset = _zip_buffer_offset(buffer);
282 zip_buffer_t *cd_buffer;
283
284 if (_zip_buffer_left(buffer) < EOCDLEN) {
285 /* not enough bytes left for comment */
286 zip_error_set(error, ZIP_ER_NOZIP, 0);
287 return NULL;
288 }
289
290 /* check for end-of-central-dir magic */
291 if (memcmp(_zip_buffer_get(buffer, 4), EOCD_MAGIC, 4) != 0) {
292 zip_error_set(error, ZIP_ER_NOZIP, 0);
293 return NULL;
294 }
295
296 if (eocd_offset >= EOCD64LOCLEN && memcmp(_zip_buffer_data(buffer) + eocd_offset - EOCD64LOCLEN, EOCD64LOC_MAGIC, 4) == 0) {
297 _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);
298 cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);
299 }
300 else {
301 _zip_buffer_set_offset(buffer, eocd_offset);
302 cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);
303 }
304
305 if (cd == NULL)
306 return NULL;
307
308 _zip_buffer_set_offset(buffer, eocd_offset + 20);
309 comment_len = _zip_buffer_get_16(buffer);
310
311 if (cd->offset + cd->size > buf_offset + eocd_offset) {
312 /* cdir spans past EOCD record */
313 zip_error_set(error, ZIP_ER_INCONS, 0);
314 _zip_cdir_free(cd);
315 return NULL;
316 }
317
318 if (comment_len || (za->open_flags & ZIP_CHECKCONS)) {
319 zip_uint64_t tail_len;
320
321 _zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);
322 tail_len = _zip_buffer_left(buffer);
323
324 if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {
325 zip_error_set(error, ZIP_ER_INCONS, 0);
326 _zip_cdir_free(cd);
327 return NULL;
328 }
329
330 if (comment_len) {
331 if ((cd->comment=_zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {
332 _zip_cdir_free(cd);
333 return NULL;
334 }
335 }
336 }
337
338 if (cd->offset >= buf_offset) {
339 zip_uint8_t *data;
340 /* if buffer already read in, use it */
341 _zip_buffer_set_offset(buffer, cd->offset - buf_offset);
342
343 if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {
344 zip_error_set(error, ZIP_ER_INCONS, 0);
345 _zip_cdir_free(cd);
346 return NULL;
347 }
348 if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {
349 zip_error_set(error, ZIP_ER_MEMORY, 0);
350 _zip_cdir_free(cd);
351 return NULL;
352 }
353 }
354 else {
355 cd_buffer = NULL;
356
357 if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {
358 _zip_error_set_from_source(error, za->src);
359 _zip_cdir_free(cd);
360 return NULL;
361 }
362
363 /* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */
364 if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) {
365 zip_error_set(error, ZIP_ER_NOZIP, 0);
366 _zip_cdir_free(cd);
367 return NULL;
368 }
369 }
370
371 left = (zip_uint64_t)cd->size;
372 i=0;
373 while (i<cd->nentry && left > 0) {
374 zip_int64_t entry_size;
375 if ((cd->entry[i].orig=_zip_dirent_new()) == NULL || (entry_size = _zip_dirent_read(cd->entry[i].orig, za->src, cd_buffer, false, error)) < 0) {
376 _zip_cdir_free(cd);
377 _zip_buffer_free(cd_buffer);
378 return NULL;
379 }
380 i++;
381 left -= (zip_uint64_t)entry_size;
382 }
383
384 if (i != cd->nentry) {
385 zip_error_set(error, ZIP_ER_INCONS, 0);
386 _zip_buffer_free(cd_buffer);
387 _zip_cdir_free(cd);
388 return NULL;
389 }
390
391 if (za->open_flags & ZIP_CHECKCONS) {
392 bool ok;
393
394 if (cd_buffer) {
395 ok = _zip_buffer_eof(cd_buffer);
396 }
397 else {
398 zip_int64_t offset = zip_source_tell(za->src);
399
400 if (offset < 0) {
401 _zip_error_set_from_source(error, za->src);
402 _zip_buffer_free(cd_buffer);
403 _zip_cdir_free(cd);
404 return NULL;
405 }
406 ok = ((zip_uint64_t)offset == cd->offset + cd->size);
407 }
408
409 if (!ok) {
410 zip_error_set(error, ZIP_ER_INCONS, 0);
411 _zip_buffer_free(cd_buffer);
412 _zip_cdir_free(cd);
413 return NULL;
414 }
415 }
416
417 _zip_buffer_free(cd_buffer);
418 return cd;
419 }
420
421
422 /* _zip_checkcons:
423 Checks the consistency of the central directory by comparing central
424 directory entries with local headers and checking for plausible
425 file and header offsets. Returns -1 if not plausible, else the
426 difference between the lowest and the highest fileposition reached */
427
428 static zip_int64_t
429 _zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error)
430 {
431 zip_uint64_t i;
432 zip_uint64_t min, max, j;
433 struct zip_dirent temp;
434
435 _zip_dirent_init(&temp);
436 if (cd->nentry) {
437 max = cd->entry[0].orig->offset;
438 min = cd->entry[0].orig->offset;
439 }
440 else
441 min = max = 0;
442
443 for (i=0; i<cd->nentry; i++) {
444 if (cd->entry[i].orig->offset < min)
445 min = cd->entry[i].orig->offset;
446 if (min > (zip_uint64_t)cd->offset) {
447 zip_error_set(error, ZIP_ER_NOZIP, 0);
448 return -1;
449 }
450
451 j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size
452 + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;
453 if (j > max)
454 max = j;
455 if (max > (zip_uint64_t)cd->offset) {
456 zip_error_set(error, ZIP_ER_NOZIP, 0);
457 return -1;
458 }
459
460 if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {
461 _zip_error_set_from_source(error, za->src);
462 return -1;
463 }
464
465 if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) {
466 _zip_dirent_finalize(&temp);
467 return -1;
468 }
469
470 if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {
471 zip_error_set(error, ZIP_ER_INCONS, 0);
472 _zip_dirent_finalize(&temp);
473 return -1;
474 }
475
476 cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields);
477 cd->entry[i].orig->local_extra_fields_read = 1;
478 temp.extra_fields = NULL;
479
480 _zip_dirent_finalize(&temp);
481 }
482
483 return (max-min) < ZIP_INT64_MAX ? (zip_int64_t)(max-min) : ZIP_INT64_MAX;
484 }
485
486
487 /* _zip_headercomp:
488 compares a central directory entry and a local file header
489 Return 0 if they are consistent, -1 if not. */
490
491 static int
492 _zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local)
493 {
494 if ((central->version_needed != local->version_needed)
495 #if 0
496 /* some zip-files have different values in local
497 and global headers for the bitflags */
498 || (central->bitflags != local->bitflags)
499 #endif
500 || (central->comp_method != local->comp_method)
501 || (central->last_mod != local->last_mod)
502 || !_zip_string_equal(central->filename, local->filename))
503 return -1;
504
505 if ((central->crc != local->crc) || (central->comp_size != local->comp_size)
506 || (central->uncomp_size != local->uncomp_size)) {
507 /* InfoZip stores valid values in local header even when data descriptor is used.
508 This is in violation of the appnote. */
509 if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0
510 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))
511 return -1;
512 }
513
514 return 0;
515 }
516
517
518 static zip_t *
519 _zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error)
520 {
521 zip_t *za;
522
523 if ((za = _zip_new(error)) == NULL) {
524 return NULL;
525 }
526
527 za->src = src;
528 za->open_flags = flags;
529 if (flags & ZIP_RDONLY) {
530 za->flags |= ZIP_AFL_RDONLY;
531 za->ch_flags |= ZIP_AFL_RDONLY;
532 }
533 return za;
534 }
535
536
537 /*
538 * tests for file existence
539 */
540 static exists_t
541 _zip_file_exists(zip_source_t *src, zip_error_t *error)
542 {
543 struct zip_stat st;
544
545 zip_stat_init(&st);
546 if (zip_source_stat(src, &st) != 0) {
547 zip_error_t *src_error = zip_source_error(src);
548 if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {
549 return EXISTS_NOT;
550 }
551 _zip_error_copy(error, src_error);
552 return EXISTS_ERROR;
553 }
554
555 return (st.valid & ZIP_STAT_SIZE) && st.size == 0 ? EXISTS_EMPTY : EXISTS_NONEMPTY;
556 }
557
558
559 static zip_cdir_t *
560 _zip_find_central_dir(zip_t *za, zip_uint64_t len)
561 {
562 zip_cdir_t *cdir, *cdirnew;
563 zip_uint8_t *match;
564 zip_int64_t buf_offset;
565 zip_uint64_t buflen;
566 zip_int64_t a;
567 zip_int64_t best;
568 zip_error_t error;
569 zip_buffer_t *buffer;
570
571 if (len < EOCDLEN) {
572 zip_error_set(&za->error, ZIP_ER_NOZIP, 0);
573 return NULL;
574 }
575
576 buflen = (len < CDBUFSIZE ? len : CDBUFSIZE);
577 if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) {
578 zip_error_t *src_error = zip_source_error(za->src);
579 if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
580 /* seek before start of file on my machine */
581 _zip_error_copy(&za->error, src_error);
582 return NULL;
583 }
584 }
585 if ((buf_offset = zip_source_tell(za->src)) < 0) {
586 _zip_error_set_from_source(&za->error, za->src);
587 return NULL;
588 }
589
590 if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) {
591 return NULL;
592 }
593
594 best = -1;
595 cdir = NULL;
596 if (buflen >= CDBUFSIZE) {
597 /* EOCD64 locator is before EOCD, so leave place for it */
598 _zip_buffer_set_offset(buffer, EOCD64LOCLEN);
599 }
600 zip_error_set(&error, ZIP_ER_NOZIP, 0);
601
602 match = _zip_buffer_get(buffer, 0);
603 while ((match=_zip_memmem(match, _zip_buffer_left(buffer)-(EOCDLEN-4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) {
604 _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
605 if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {
606 if (cdir) {
607 if (best <= 0) {
608 best = _zip_checkcons(za, cdir, &error);
609 }
610
611 a = _zip_checkcons(za, cdirnew, &error);
612 if (best < a) {
613 _zip_cdir_free(cdir);
614 cdir = cdirnew;
615 best = a;
616 }
617 else {
618 _zip_cdir_free(cdirnew);
619 }
620 }
621 else {
622 cdir = cdirnew;
623 if (za->open_flags & ZIP_CHECKCONS)
624 best = _zip_checkcons(za, cdir, &error);
625 else {
626 best = 0;
627 }
628 }
629 cdirnew = NULL;
630 }
631
632 match++;
633 _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
634 }
635
636 _zip_buffer_free(buffer);
637
638 if (best < 0) {
639 _zip_error_copy(&za->error, &error);
640 _zip_cdir_free(cdir);
641 return NULL;
642 }
643
644 return cdir;
645 }
646
647
648 static unsigned char *
649 _zip_memmem(const unsigned char *big, size_t biglen, const unsigned char *little, size_t littlelen)
650 {
651 const unsigned char *p;
652
653 if ((biglen < littlelen) || (littlelen == 0))
654 return NULL;
655 p = big-1;
656 while ((p=(const unsigned char *)
657 memchr(p+1, little[0], (size_t)(big-(p+1))+(size_t)(biglen-littlelen)+1)) != NULL) {
658 if (memcmp(p+1, little+1, littlelen-1)==0)
659 return (unsigned char *)p;
660 }
661
662 return NULL;
663 }
664
665
666 static zip_cdir_t *
667 _zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)
668 {
669 zip_cdir_t *cd;
670 zip_uint64_t i, nentry, size, offset, eocd_offset;
671
672 if (_zip_buffer_left(buffer) < EOCDLEN) {
673 zip_error_set(error, ZIP_ER_INCONS, 0);
674 return NULL;
675 }
676
677 eocd_offset = _zip_buffer_offset(buffer);
678
679 _zip_buffer_get(buffer, 4); /* magic already verified */
680
681 if (_zip_buffer_get_32(buffer) != 0) {
682 zip_error_set(error, ZIP_ER_MULTIDISK, 0);
683 return NULL;
684 }
685
686 /* number of cdir-entries on this disk */
687 i = _zip_buffer_get_16(buffer);
688 /* number of cdir-entries */
689 nentry = _zip_buffer_get_16(buffer);
690
691 if (nentry != i) {
692 zip_error_set(error, ZIP_ER_NOZIP, 0);
693 return NULL;
694 }
695
696 size = _zip_buffer_get_32(buffer);
697 offset = _zip_buffer_get_32(buffer);
698
699 if (offset+size < offset) {
700 zip_error_set(error, ZIP_ER_SEEK, EFBIG);
701 return NULL;
702 }
703
704 if (offset+size > buf_offset + eocd_offset) {
705 /* cdir spans past EOCD record */
706 zip_error_set(error, ZIP_ER_INCONS, 0);
707 return NULL;
708 }
709
710 if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) {
711 zip_error_set(error, ZIP_ER_INCONS, 0);
712 return NULL;
713 }
714
715 if ((cd=_zip_cdir_new(nentry, error)) == NULL)
716 return NULL;
717
718 cd->size = size;
719 cd->offset = offset;
720
721 return cd;
722 }
723
724
725 static zip_cdir_t *
726 _zip_read_eocd64(zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)
727 {
728 zip_cdir_t *cd;
729 zip_uint64_t offset;
730 zip_uint8_t eocd[EOCD64LEN];
731 zip_uint64_t eocd_offset;
732 zip_uint64_t size, nentry, i, eocdloc_offset;
733 bool free_buffer;
734 zip_uint32_t num_disks, num_disks64, eocd_disk, eocd_disk64;
735
736 eocdloc_offset = _zip_buffer_offset(buffer);
737
738 _zip_buffer_get(buffer, 4); /* magic already verified */
739
740 num_disks = _zip_buffer_get_16(buffer);
741 eocd_disk = _zip_buffer_get_16(buffer);
742 eocd_offset = _zip_buffer_get_64(buffer);
743
744 if (eocd_offset > ZIP_INT64_MAX || eocd_offset + EOCD64LEN < eocd_offset) {
745 zip_error_set(error, ZIP_ER_SEEK, EFBIG);
746 return NULL;
747 }
748
749 if (eocd_offset + EOCD64LEN > eocdloc_offset + buf_offset) {
750 zip_error_set(error, ZIP_ER_INCONS, 0);
751 return NULL;
752 }
753
754 if (eocd_offset >= buf_offset && eocd_offset + EOCD64LEN <= buf_offset + _zip_buffer_size(buffer)) {
755 _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);
756 free_buffer = false;
757 }
758 else {
759 if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) {
760 _zip_error_set_from_source(error, src);
761 return NULL;
762 }
763 if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {
764 return NULL;
765 }
766 free_buffer = true;
767 }
768
769 if (memcmp(_zip_buffer_get(buffer, 4), EOCD64_MAGIC, 4) != 0) {
770 zip_error_set(error, ZIP_ER_INCONS, 0);
771 if (free_buffer) {
772 _zip_buffer_free(buffer);
773 }
774 return NULL;
775 }
776
777 size = _zip_buffer_get_64(buffer);
778
779 if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) {
780 zip_error_set(error, ZIP_ER_INCONS, 0);
781 if (free_buffer) {
782 _zip_buffer_free(buffer);
783 }
784 return NULL;
785 }
786
787 _zip_buffer_get(buffer, 4); /* skip version made by/needed */
788
789 num_disks64 = _zip_buffer_get_32(buffer);
790 eocd_disk64 = _zip_buffer_get_32(buffer);
791
792 /* if eocd values are 0xffff, we have to use eocd64 values.
793 otherwise, if the values are not the same, it's inconsistent;
794 in any case, if the value is not 0, we don't support it */
795 if (num_disks == 0xffff) {
796 num_disks = num_disks64;
797 }
798 if (eocd_disk == 0xffff) {
799 eocd_disk = eocd_disk64;
800 }
801 if ((flags & ZIP_CHECKCONS) && (eocd_disk != eocd_disk64 || num_disks != num_disks64)) {
802 zip_error_set(error, ZIP_ER_INCONS, 0);
803 return NULL;
804 }
805 if (num_disks != 0 || eocd_disk != 0) {
806 zip_error_set(error, ZIP_ER_MULTIDISK, 0);
807 return NULL;
808 }
809
810 nentry = _zip_buffer_get_64(buffer);
811 i = _zip_buffer_get_64(buffer);
812
813 if (nentry != i) {
814 zip_error_set(error, ZIP_ER_MULTIDISK, 0);
815 if (free_buffer) {
816 _zip_buffer_free(buffer);
817 }
818 return NULL;
819 }
820
821 size = _zip_buffer_get_64(buffer);
822 offset = _zip_buffer_get_64(buffer);
823
824 if (!_zip_buffer_ok(buffer)) {
825 zip_error_set(error, ZIP_ER_INTERNAL, 0);
826 if (free_buffer) {
827 _zip_buffer_free(buffer);
828 }
829 return NULL;
830 }
831
832 if (free_buffer) {
833 _zip_buffer_free(buffer);
834 }
835
836 if (offset > ZIP_INT64_MAX || offset+size < offset) {
837 zip_error_set(error, ZIP_ER_SEEK, EFBIG);
838 return NULL;
839 }
840 if ((flags & ZIP_CHECKCONS) && offset+size != eocd_offset) {
841 zip_error_set(error, ZIP_ER_INCONS, 0);
842 return NULL;
843 }
844
845 if ((cd=_zip_cdir_new(nentry, error)) == NULL)
846 return NULL;
847
848
849 cd->size = size;
850 cd->offset = offset;
851
852 return cd;
853 }