Mercurial > embed
annotate libzip/lib/zip_open.c @ 63:b3c185090dc2
cmake: use BUILD_INTERFACE, closes #881 @10m
author | David Demelier <markand@malikania.fr> |
---|---|
date | Fri, 13 Jul 2018 12:32:37 +0200 |
parents | 056ee6b5913e |
children |
rev | line source |
---|---|
4 | 1 /* |
2 zip_open.c -- open zip archive by name | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
3 Copyright (C) 1999-2016 Dieter Baron and Thomas Klausner |
4 | 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. | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
20 |
4 | 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; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
91 |
4 | 92 unsigned int flags; |
93 zip_int64_t supported; | |
94 exists_t exists; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
95 |
4 | 96 if (_flags < 0 || src == NULL) { |
97 zip_error_set(error, ZIP_ER_INVAL, 0); | |
98 return NULL; | |
99 } | |
100 flags = (unsigned int)_flags; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
101 |
4 | 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); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
121 switch (exists) { |
4 | 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 | |
161 zip_t * | |
162 _zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error) | |
163 { | |
164 zip_t *za; | |
165 zip_cdir_t *cdir; | |
166 struct zip_stat st; | |
167 zip_uint64_t len, idx; | |
168 | |
169 zip_stat_init(&st); | |
170 if (zip_source_stat(src, &st) < 0) { | |
171 _zip_error_set_from_source(error, src); | |
172 return NULL; | |
173 } | |
174 if ((st.valid & ZIP_STAT_SIZE) == 0) { | |
175 zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP); | |
176 return NULL; | |
177 } | |
178 len = st.size; | |
179 | |
180 /* treat empty files as empty archives */ | |
181 if (len == 0) { | |
182 if ((za=_zip_allocate_new(src, flags, error)) == NULL) { | |
183 zip_source_free(src); | |
184 return NULL; | |
185 } | |
186 | |
187 return za; | |
188 } | |
189 | |
190 if ((za=_zip_allocate_new(src, flags, error)) == NULL) { | |
191 return NULL; | |
192 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
193 |
4 | 194 if ((cdir = _zip_find_central_dir(za, len)) == NULL) { |
195 _zip_error_copy(error, &za->error); | |
196 /* keep src so discard does not get rid of it */ | |
197 zip_source_keep(src); | |
198 zip_discard(za); | |
199 return NULL; | |
200 } | |
201 | |
202 za->entry = cdir->entry; | |
203 za->nentry = cdir->nentry; | |
204 za->nentry_alloc = cdir->nentry_alloc; | |
205 za->comment_orig = cdir->comment; | |
206 | |
207 free(cdir); | |
208 | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
209 _zip_hash_reserve_capacity(za->names, za->nentry, &za->error); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
210 |
4 | 211 for (idx = 0; idx < za->nentry; idx++) { |
212 const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error); | |
213 if (name == NULL) { | |
214 /* keep src so discard does not get rid of it */ | |
215 zip_source_keep(src); | |
216 zip_discard(za); | |
217 return NULL; | |
218 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
219 |
4 | 220 if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) { |
221 if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) { | |
222 _zip_error_copy(error, &za->error); | |
223 /* keep src so discard does not get rid of it */ | |
224 zip_source_keep(src); | |
225 zip_discard(za); | |
226 return NULL; | |
227 } | |
228 } | |
229 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
230 |
4 | 231 za->ch_flags = za->flags; |
232 | |
233 return za; | |
234 } | |
235 | |
236 | |
237 void | |
238 _zip_set_open_error(int *zep, const zip_error_t *err, int ze) | |
239 { | |
240 if (err) { | |
241 ze = zip_error_code_zip(err); | |
242 if (zip_error_system_type(err) == ZIP_ET_SYS) { | |
243 errno = zip_error_code_system(err); | |
244 } | |
245 } | |
246 | |
247 if (zep) | |
248 *zep = ze; | |
249 } | |
250 | |
251 | |
252 /* _zip_readcdir: | |
253 tries to find a valid end-of-central-directory at the beginning of | |
254 buf, and then the corresponding central directory entries. | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
255 Returns a struct zip_cdir which contains the central directory |
4 | 256 entries, or NULL if unsuccessful. */ |
257 | |
258 static zip_cdir_t * | |
259 _zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error) | |
260 { | |
261 zip_cdir_t *cd; | |
262 zip_uint16_t comment_len; | |
263 zip_uint64_t i, left; | |
264 zip_uint64_t eocd_offset = _zip_buffer_offset(buffer); | |
265 zip_buffer_t *cd_buffer; | |
266 | |
267 if (_zip_buffer_left(buffer) < EOCDLEN) { | |
268 /* not enough bytes left for comment */ | |
269 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
270 return NULL; | |
271 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
272 |
4 | 273 /* check for end-of-central-dir magic */ |
274 if (memcmp(_zip_buffer_get(buffer, 4), EOCD_MAGIC, 4) != 0) { | |
275 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
276 return NULL; | |
277 } | |
278 | |
279 if (eocd_offset >= EOCD64LOCLEN && memcmp(_zip_buffer_data(buffer) + eocd_offset - EOCD64LOCLEN, EOCD64LOC_MAGIC, 4) == 0) { | |
280 _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN); | |
281 cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error); | |
282 } | |
283 else { | |
284 _zip_buffer_set_offset(buffer, eocd_offset); | |
285 cd = _zip_read_eocd(buffer, buf_offset, za->flags, error); | |
286 } | |
287 | |
288 if (cd == NULL) | |
289 return NULL; | |
290 | |
291 _zip_buffer_set_offset(buffer, eocd_offset + 20); | |
292 comment_len = _zip_buffer_get_16(buffer); | |
293 | |
294 if (cd->offset + cd->size > buf_offset + eocd_offset) { | |
295 /* cdir spans past EOCD record */ | |
296 zip_error_set(error, ZIP_ER_INCONS, 0); | |
297 _zip_cdir_free(cd); | |
298 return NULL; | |
299 } | |
300 | |
301 if (comment_len || (za->open_flags & ZIP_CHECKCONS)) { | |
302 zip_uint64_t tail_len; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
303 |
4 | 304 _zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN); |
305 tail_len = _zip_buffer_left(buffer); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
306 |
4 | 307 if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) { |
308 zip_error_set(error, ZIP_ER_INCONS, 0); | |
309 _zip_cdir_free(cd); | |
310 return NULL; | |
311 } | |
312 | |
313 if (comment_len) { | |
314 if ((cd->comment=_zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) { | |
315 _zip_cdir_free(cd); | |
316 return NULL; | |
317 } | |
318 } | |
319 } | |
320 | |
321 if (cd->offset >= buf_offset) { | |
322 zip_uint8_t *data; | |
323 /* if buffer already read in, use it */ | |
324 _zip_buffer_set_offset(buffer, cd->offset - buf_offset); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
325 |
4 | 326 if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) { |
327 zip_error_set(error, ZIP_ER_INCONS, 0); | |
328 _zip_cdir_free(cd); | |
329 return NULL; | |
330 } | |
331 if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) { | |
332 zip_error_set(error, ZIP_ER_MEMORY, 0); | |
333 _zip_cdir_free(cd); | |
334 return NULL; | |
335 } | |
336 } | |
337 else { | |
338 cd_buffer = NULL; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
339 |
4 | 340 if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) { |
341 _zip_error_set_from_source(error, za->src); | |
342 _zip_cdir_free(cd); | |
343 return NULL; | |
344 } | |
345 | |
346 /* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */ | |
347 if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) { | |
348 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
349 _zip_cdir_free(cd); | |
350 return NULL; | |
351 } | |
352 } | |
353 | |
354 left = (zip_uint64_t)cd->size; | |
355 i=0; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
356 while (left > 0) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
357 bool grown = false; |
4 | 358 zip_int64_t entry_size; |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
359 |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
360 if (i == cd->nentry) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
361 /* InfoZIP has a hack to avoid using Zip64: it stores nentries % 0x10000 */ |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
362 /* This hack isn't applicable if we're using Zip64, or if there is no central directory entry following. */ |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
363 |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
364 if (cd->is_zip64 || left < CDENTRYSIZE) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
365 break; |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
366 } |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
367 |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
368 if (!_zip_cdir_grow(cd, 0x10000, error)) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
369 _zip_cdir_free(cd); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
370 _zip_buffer_free(cd_buffer); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
371 return NULL; |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
372 } |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
373 grown = true; |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
374 } |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
375 |
4 | 376 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) { |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
377 if (grown && zip_error_code_zip(error) == ZIP_ER_NOZIP) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
378 zip_error_set(error, ZIP_ER_INCONS, 0); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
379 } |
4 | 380 _zip_cdir_free(cd); |
381 _zip_buffer_free(cd_buffer); | |
382 return NULL; | |
383 } | |
384 i++; | |
385 left -= (zip_uint64_t)entry_size; | |
386 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
387 |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
388 if (i != cd->nentry || left > 0) { |
4 | 389 zip_error_set(error, ZIP_ER_INCONS, 0); |
390 _zip_buffer_free(cd_buffer); | |
391 _zip_cdir_free(cd); | |
392 return NULL; | |
393 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
394 |
4 | 395 if (za->open_flags & ZIP_CHECKCONS) { |
396 bool ok; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
397 |
4 | 398 if (cd_buffer) { |
399 ok = _zip_buffer_eof(cd_buffer); | |
400 } | |
401 else { | |
402 zip_int64_t offset = zip_source_tell(za->src); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
403 |
4 | 404 if (offset < 0) { |
405 _zip_error_set_from_source(error, za->src); | |
406 _zip_cdir_free(cd); | |
407 return NULL; | |
408 } | |
409 ok = ((zip_uint64_t)offset == cd->offset + cd->size); | |
410 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
411 |
4 | 412 if (!ok) { |
413 zip_error_set(error, ZIP_ER_INCONS, 0); | |
414 _zip_buffer_free(cd_buffer); | |
415 _zip_cdir_free(cd); | |
416 return NULL; | |
417 } | |
418 } | |
419 | |
420 _zip_buffer_free(cd_buffer); | |
421 return cd; | |
422 } | |
423 | |
424 | |
425 /* _zip_checkcons: | |
426 Checks the consistency of the central directory by comparing central | |
427 directory entries with local headers and checking for plausible | |
428 file and header offsets. Returns -1 if not plausible, else the | |
429 difference between the lowest and the highest fileposition reached */ | |
430 | |
431 static zip_int64_t | |
432 _zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error) | |
433 { | |
434 zip_uint64_t i; | |
435 zip_uint64_t min, max, j; | |
436 struct zip_dirent temp; | |
437 | |
438 _zip_dirent_init(&temp); | |
439 if (cd->nentry) { | |
440 max = cd->entry[0].orig->offset; | |
441 min = cd->entry[0].orig->offset; | |
442 } | |
443 else | |
444 min = max = 0; | |
445 | |
446 for (i=0; i<cd->nentry; i++) { | |
447 if (cd->entry[i].orig->offset < min) | |
448 min = cd->entry[i].orig->offset; | |
449 if (min > (zip_uint64_t)cd->offset) { | |
450 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
451 return -1; | |
452 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
453 |
4 | 454 j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size |
455 + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE; | |
456 if (j > max) | |
457 max = j; | |
458 if (max > (zip_uint64_t)cd->offset) { | |
459 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
460 return -1; | |
461 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
462 |
4 | 463 if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) { |
464 _zip_error_set_from_source(error, za->src); | |
465 return -1; | |
466 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
467 |
4 | 468 if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) { |
469 _zip_dirent_finalize(&temp); | |
470 return -1; | |
471 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
472 |
4 | 473 if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) { |
474 zip_error_set(error, ZIP_ER_INCONS, 0); | |
475 _zip_dirent_finalize(&temp); | |
476 return -1; | |
477 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
478 |
4 | 479 cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields); |
480 cd->entry[i].orig->local_extra_fields_read = 1; | |
481 temp.extra_fields = NULL; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
482 |
4 | 483 _zip_dirent_finalize(&temp); |
484 } | |
485 | |
486 return (max-min) < ZIP_INT64_MAX ? (zip_int64_t)(max-min) : ZIP_INT64_MAX; | |
487 } | |
488 | |
489 | |
490 /* _zip_headercomp: | |
491 compares a central directory entry and a local file header | |
492 Return 0 if they are consistent, -1 if not. */ | |
493 | |
494 static int | |
495 _zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local) | |
496 { | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
497 if ((central->version_needed < local->version_needed) |
4 | 498 #if 0 |
499 /* some zip-files have different values in local | |
500 and global headers for the bitflags */ | |
501 || (central->bitflags != local->bitflags) | |
502 #endif | |
503 || (central->comp_method != local->comp_method) | |
504 || (central->last_mod != local->last_mod) | |
505 || !_zip_string_equal(central->filename, local->filename)) | |
506 return -1; | |
507 | |
508 if ((central->crc != local->crc) || (central->comp_size != local->comp_size) | |
509 || (central->uncomp_size != local->uncomp_size)) { | |
510 /* InfoZip stores valid values in local header even when data descriptor is used. | |
511 This is in violation of the appnote. */ | |
512 if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 | |
513 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0)) | |
514 return -1; | |
515 } | |
516 | |
517 return 0; | |
518 } | |
519 | |
520 | |
521 static zip_t * | |
522 _zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error) | |
523 { | |
524 zip_t *za; | |
525 | |
526 if ((za = _zip_new(error)) == NULL) { | |
527 return NULL; | |
528 } | |
529 | |
530 za->src = src; | |
531 za->open_flags = flags; | |
532 if (flags & ZIP_RDONLY) { | |
533 za->flags |= ZIP_AFL_RDONLY; | |
534 za->ch_flags |= ZIP_AFL_RDONLY; | |
535 } | |
536 return za; | |
537 } | |
538 | |
539 | |
540 /* | |
541 * tests for file existence | |
542 */ | |
543 static exists_t | |
544 _zip_file_exists(zip_source_t *src, zip_error_t *error) | |
545 { | |
546 struct zip_stat st; | |
547 | |
548 zip_stat_init(&st); | |
549 if (zip_source_stat(src, &st) != 0) { | |
550 zip_error_t *src_error = zip_source_error(src); | |
551 if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) { | |
552 return EXISTS_NOT; | |
553 } | |
554 _zip_error_copy(error, src_error); | |
555 return EXISTS_ERROR; | |
556 } | |
557 | |
558 return (st.valid & ZIP_STAT_SIZE) && st.size == 0 ? EXISTS_EMPTY : EXISTS_NONEMPTY; | |
559 } | |
560 | |
561 | |
562 static zip_cdir_t * | |
563 _zip_find_central_dir(zip_t *za, zip_uint64_t len) | |
564 { | |
565 zip_cdir_t *cdir, *cdirnew; | |
566 zip_uint8_t *match; | |
567 zip_int64_t buf_offset; | |
568 zip_uint64_t buflen; | |
569 zip_int64_t a; | |
570 zip_int64_t best; | |
571 zip_error_t error; | |
572 zip_buffer_t *buffer; | |
573 | |
574 if (len < EOCDLEN) { | |
575 zip_error_set(&za->error, ZIP_ER_NOZIP, 0); | |
576 return NULL; | |
577 } | |
578 | |
579 buflen = (len < CDBUFSIZE ? len : CDBUFSIZE); | |
580 if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) { | |
581 zip_error_t *src_error = zip_source_error(za->src); | |
582 if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) { | |
583 /* seek before start of file on my machine */ | |
584 _zip_error_copy(&za->error, src_error); | |
585 return NULL; | |
586 } | |
587 } | |
588 if ((buf_offset = zip_source_tell(za->src)) < 0) { | |
589 _zip_error_set_from_source(&za->error, za->src); | |
590 return NULL; | |
591 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
592 |
4 | 593 if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) { |
594 return NULL; | |
595 } | |
596 | |
597 best = -1; | |
598 cdir = NULL; | |
599 if (buflen >= CDBUFSIZE) { | |
600 /* EOCD64 locator is before EOCD, so leave place for it */ | |
601 _zip_buffer_set_offset(buffer, EOCD64LOCLEN); | |
602 } | |
603 zip_error_set(&error, ZIP_ER_NOZIP, 0); | |
604 | |
605 match = _zip_buffer_get(buffer, 0); | |
606 while ((match=_zip_memmem(match, _zip_buffer_left(buffer)-(EOCDLEN-4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) { | |
607 _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer))); | |
608 if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) { | |
609 if (cdir) { | |
610 if (best <= 0) { | |
611 best = _zip_checkcons(za, cdir, &error); | |
612 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
613 |
4 | 614 a = _zip_checkcons(za, cdirnew, &error); |
615 if (best < a) { | |
616 _zip_cdir_free(cdir); | |
617 cdir = cdirnew; | |
618 best = a; | |
619 } | |
620 else { | |
621 _zip_cdir_free(cdirnew); | |
622 } | |
623 } | |
624 else { | |
625 cdir = cdirnew; | |
626 if (za->open_flags & ZIP_CHECKCONS) | |
627 best = _zip_checkcons(za, cdir, &error); | |
628 else { | |
629 best = 0; | |
630 } | |
631 } | |
632 cdirnew = NULL; | |
633 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
634 |
4 | 635 match++; |
636 _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer))); | |
637 } | |
638 | |
639 _zip_buffer_free(buffer); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
640 |
4 | 641 if (best < 0) { |
642 _zip_error_copy(&za->error, &error); | |
643 _zip_cdir_free(cdir); | |
644 return NULL; | |
645 } | |
646 | |
647 return cdir; | |
648 } | |
649 | |
650 | |
651 static unsigned char * | |
652 _zip_memmem(const unsigned char *big, size_t biglen, const unsigned char *little, size_t littlelen) | |
653 { | |
654 const unsigned char *p; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
655 |
4 | 656 if ((biglen < littlelen) || (littlelen == 0)) |
657 return NULL; | |
658 p = big-1; | |
659 while ((p=(const unsigned char *) | |
660 memchr(p+1, little[0], (size_t)(big-(p+1))+(size_t)(biglen-littlelen)+1)) != NULL) { | |
661 if (memcmp(p+1, little+1, littlelen-1)==0) | |
662 return (unsigned char *)p; | |
663 } | |
664 | |
665 return NULL; | |
666 } | |
667 | |
668 | |
669 static zip_cdir_t * | |
670 _zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error) | |
671 { | |
672 zip_cdir_t *cd; | |
673 zip_uint64_t i, nentry, size, offset, eocd_offset; | |
674 | |
675 if (_zip_buffer_left(buffer) < EOCDLEN) { | |
676 zip_error_set(error, ZIP_ER_INCONS, 0); | |
677 return NULL; | |
678 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
679 |
4 | 680 eocd_offset = _zip_buffer_offset(buffer); |
681 | |
682 _zip_buffer_get(buffer, 4); /* magic already verified */ | |
683 | |
684 if (_zip_buffer_get_32(buffer) != 0) { | |
685 zip_error_set(error, ZIP_ER_MULTIDISK, 0); | |
686 return NULL; | |
687 } | |
688 | |
689 /* number of cdir-entries on this disk */ | |
690 i = _zip_buffer_get_16(buffer); | |
691 /* number of cdir-entries */ | |
692 nentry = _zip_buffer_get_16(buffer); | |
693 | |
694 if (nentry != i) { | |
695 zip_error_set(error, ZIP_ER_NOZIP, 0); | |
696 return NULL; | |
697 } | |
698 | |
699 size = _zip_buffer_get_32(buffer); | |
700 offset = _zip_buffer_get_32(buffer); | |
701 | |
702 if (offset+size < offset) { | |
703 zip_error_set(error, ZIP_ER_SEEK, EFBIG); | |
704 return NULL; | |
705 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
706 |
4 | 707 if (offset+size > buf_offset + eocd_offset) { |
708 /* cdir spans past EOCD record */ | |
709 zip_error_set(error, ZIP_ER_INCONS, 0); | |
710 return NULL; | |
711 } | |
712 | |
713 if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) { | |
714 zip_error_set(error, ZIP_ER_INCONS, 0); | |
715 return NULL; | |
716 } | |
717 | |
718 if ((cd=_zip_cdir_new(nentry, error)) == NULL) | |
719 return NULL; | |
720 | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
721 cd->is_zip64 = false; |
4 | 722 cd->size = size; |
723 cd->offset = offset; | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
724 |
4 | 725 return cd; |
726 } | |
727 | |
728 | |
729 static zip_cdir_t * | |
730 _zip_read_eocd64(zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error) | |
731 { | |
732 zip_cdir_t *cd; | |
733 zip_uint64_t offset; | |
734 zip_uint8_t eocd[EOCD64LEN]; | |
735 zip_uint64_t eocd_offset; | |
736 zip_uint64_t size, nentry, i, eocdloc_offset; | |
737 bool free_buffer; | |
738 zip_uint32_t num_disks, num_disks64, eocd_disk, eocd_disk64; | |
739 | |
740 eocdloc_offset = _zip_buffer_offset(buffer); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
741 |
4 | 742 _zip_buffer_get(buffer, 4); /* magic already verified */ |
743 | |
744 num_disks = _zip_buffer_get_16(buffer); | |
745 eocd_disk = _zip_buffer_get_16(buffer); | |
746 eocd_offset = _zip_buffer_get_64(buffer); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
747 |
4 | 748 if (eocd_offset > ZIP_INT64_MAX || eocd_offset + EOCD64LEN < eocd_offset) { |
749 zip_error_set(error, ZIP_ER_SEEK, EFBIG); | |
750 return NULL; | |
751 } | |
752 | |
753 if (eocd_offset + EOCD64LEN > eocdloc_offset + buf_offset) { | |
754 zip_error_set(error, ZIP_ER_INCONS, 0); | |
755 return NULL; | |
756 } | |
757 | |
758 if (eocd_offset >= buf_offset && eocd_offset + EOCD64LEN <= buf_offset + _zip_buffer_size(buffer)) { | |
759 _zip_buffer_set_offset(buffer, eocd_offset - buf_offset); | |
760 free_buffer = false; | |
761 } | |
762 else { | |
763 if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) { | |
764 _zip_error_set_from_source(error, src); | |
765 return NULL; | |
766 } | |
767 if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) { | |
768 return NULL; | |
769 } | |
770 free_buffer = true; | |
771 } | |
772 | |
773 if (memcmp(_zip_buffer_get(buffer, 4), EOCD64_MAGIC, 4) != 0) { | |
774 zip_error_set(error, ZIP_ER_INCONS, 0); | |
775 if (free_buffer) { | |
776 _zip_buffer_free(buffer); | |
777 } | |
778 return NULL; | |
779 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
780 |
4 | 781 size = _zip_buffer_get_64(buffer); |
782 | |
783 if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) { | |
784 zip_error_set(error, ZIP_ER_INCONS, 0); | |
785 if (free_buffer) { | |
786 _zip_buffer_free(buffer); | |
787 } | |
788 return NULL; | |
789 } | |
790 | |
791 _zip_buffer_get(buffer, 4); /* skip version made by/needed */ | |
792 | |
793 num_disks64 = _zip_buffer_get_32(buffer); | |
794 eocd_disk64 = _zip_buffer_get_32(buffer); | |
795 | |
796 /* if eocd values are 0xffff, we have to use eocd64 values. | |
797 otherwise, if the values are not the same, it's inconsistent; | |
798 in any case, if the value is not 0, we don't support it */ | |
799 if (num_disks == 0xffff) { | |
800 num_disks = num_disks64; | |
801 } | |
802 if (eocd_disk == 0xffff) { | |
803 eocd_disk = eocd_disk64; | |
804 } | |
805 if ((flags & ZIP_CHECKCONS) && (eocd_disk != eocd_disk64 || num_disks != num_disks64)) { | |
806 zip_error_set(error, ZIP_ER_INCONS, 0); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
807 if (free_buffer) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
808 _zip_buffer_free(buffer); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
809 } |
4 | 810 return NULL; |
811 } | |
812 if (num_disks != 0 || eocd_disk != 0) { | |
813 zip_error_set(error, ZIP_ER_MULTIDISK, 0); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
814 if (free_buffer) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
815 _zip_buffer_free(buffer); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
816 } |
4 | 817 return NULL; |
818 } | |
819 | |
820 nentry = _zip_buffer_get_64(buffer); | |
821 i = _zip_buffer_get_64(buffer); | |
822 | |
823 if (nentry != i) { | |
824 zip_error_set(error, ZIP_ER_MULTIDISK, 0); | |
825 if (free_buffer) { | |
826 _zip_buffer_free(buffer); | |
827 } | |
828 return NULL; | |
829 } | |
830 | |
831 size = _zip_buffer_get_64(buffer); | |
832 offset = _zip_buffer_get_64(buffer); | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
833 |
4 | 834 if (!_zip_buffer_ok(buffer)) { |
835 zip_error_set(error, ZIP_ER_INTERNAL, 0); | |
836 if (free_buffer) { | |
837 _zip_buffer_free(buffer); | |
838 } | |
839 return NULL; | |
840 } | |
841 | |
842 if (free_buffer) { | |
843 _zip_buffer_free(buffer); | |
844 } | |
845 | |
846 if (offset > ZIP_INT64_MAX || offset+size < offset) { | |
847 zip_error_set(error, ZIP_ER_SEEK, EFBIG); | |
848 return NULL; | |
849 } | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
850 if (offset+size > buf_offset + eocd_offset) { |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
851 /* cdir spans past EOCD record */ |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
852 zip_error_set(error, ZIP_ER_INCONS, 0); |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
853 return NULL; |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
854 } |
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
855 if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) { |
4 | 856 zip_error_set(error, ZIP_ER_INCONS, 0); |
857 return NULL; | |
858 } | |
859 | |
860 if ((cd=_zip_cdir_new(nentry, error)) == NULL) | |
861 return NULL; | |
862 | |
56
056ee6b5913e
libzip: update to 1.3.0, closes #654
David Demelier <markand@malikania.fr>
parents:
4
diff
changeset
|
863 cd->is_zip64 = true; |
4 | 864 cd->size = size; |
865 cd->offset = offset; | |
866 | |
867 return cd; | |
868 } |