miniz.c

filter: Statementstmt 0.0% 0 / 3210 Branchbran 0.0% 0 / 3416 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 0.0% 0 / 6626 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« blib/lib/Sereal/Performance.pm ↑ Summary snappy/csnappy_decompress.c »
1 #include "miniz.h"
2 /**************************************************************************
3 *
4 * Copyright 2013-2014 RAD Game Tools and Valve Software
5 * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 * THE SOFTWARE.
25 *
26 **************************************************************************/
27  
28  
29  
30 typedef unsigned char mz_validate_uint16[sizeof(mz_uint16) == 2 ? 1 : -1];
31 typedef unsigned char mz_validate_uint32[sizeof(mz_uint32) == 4 ? 1 : -1];
32 typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1];
33  
34 #ifdef __cplusplus
35 extern "C"
36 {
37 #endif
38  
39 /* ------------------- zlib-style API's */
40  
41 0 mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
42 {
43 0 mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
44 0 size_t block_len = buf_len % 5552;
45 0 ▶ if (!ptr)
Branch: 1 branch
BranchTrueFalseTotal
if (!ptr) 0 0 0
46 0 return MZ_ADLER32_INIT;
47 0 ▶ while (buf_len)
Branch: 1 branch
BranchTrueFalseTotal
while (buf_len) 0 0 0
48 {
49 0 ▶ for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i + 7 < block_len; i += 8, ptr += 8) 0 0 0
50 {
51 0 s1 += ptr[0], s2 += s1;
52 0 s1 += ptr[1], s2 += s1;
53 0 s1 += ptr[2], s2 += s1;
54 0 s1 += ptr[3], s2 += s1;
55 0 s1 += ptr[4], s2 += s1;
56 0 s1 += ptr[5], s2 += s1;
57 0 s1 += ptr[6], s2 += s1;
58 0 s1 += ptr[7], s2 += s1;
59 }
60 0 ▶ for (; i < block_len; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i < block_len; ++i) 0 0 0
61 0 s1 += *ptr++, s2 += s1;
62 0 s1 %= 65521U, s2 %= 65521U;
63 0 buf_len -= block_len;
64 0 block_len = 5552;
65 }
66 0 return (s2 << 16) + s1;
67 }
68  
69 /* Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C implementation that balances processor cache usage against speed": http://www.geocities.com/malbrain/ */
70 #if 0
71 mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
72 {
73 static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c,
74 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c };
75 mz_uint32 crcu32 = (mz_uint32)crc;
76 if (!ptr)
77 return MZ_CRC32_INIT;
78 crcu32 = ~crcu32;
79 while (buf_len--)
80 {
81 mz_uint8 b = *ptr++;
82 crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)];
83 crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)];
84 }
85 return ~crcu32;
86 }
87 #elif defined(USE_EXTERNAL_MZCRC)
88 /* If USE_EXTERNAL_CRC is defined, an external module will export the
89 * mz_crc32() symbol for us to use, e.g. an SSE-accelerated version.
90 * Depending on the impl, it may be necessary to ~ the input/output crc values.
91 */
92 mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len);
93 #else
94 /* Faster, but larger CPU cache footprint.
95 */
96 0 mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
97 {
98 static const mz_uint32 s_crc_table[256] = {
99 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
100 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
101 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
102 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
103 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
104 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
105 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
106 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
107 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
108 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
109 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
110 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
111 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
112 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
113 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
114 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
115 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
116 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
117 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
118 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
119 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
120 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
121 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
122 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
123 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
124 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
125 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
126 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
127 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
128 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
129 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
130 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
131 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
132 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
133 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
134 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
135 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
136 };
137  
138 0 mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
139 0 const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
140  
141 0 ▶ while (buf_len >= 4)
Branch: 1 branch
BranchTrueFalseTotal
while (buf_len >= 4) 0 0 0
142 {
143 0 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
144 0 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
145 0 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
146 0 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
147 0 pByte_buf += 4;
148 0 buf_len -= 4;
149 }
150  
151 0 ▶ while (buf_len)
Branch: 1 branch
BranchTrueFalseTotal
while (buf_len) 0 0 0
152 {
153 0 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
154 0 ++pByte_buf;
155 0 --buf_len;
156 }
157  
158 0 return ~crc32;
159 }
160 #endif
161  
162 0 void mz_free(void *p)
163 {
164 0 MZ_FREE(p);
165 0 }
166  
167 0 MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, size_t size)
168 {
169 (void)opaque, (void)items, (void)size;
170 0 return MZ_MALLOC(items * size);
171 }
172 0 MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address)
173 {
174 (void)opaque, (void)address;
175 0 MZ_FREE(address);
176 0 }
177 0 MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)
178 {
179 (void)opaque, (void)address, (void)items, (void)size;
180 0 return MZ_REALLOC(address, items * size);
181 }
182  
183 0 const char *mz_version(void)
184 {
185 0 return MZ_VERSION;
186 }
187  
188 #ifndef MINIZ_NO_ZLIB_APIS
189  
190 #ifndef MINIZ_NO_DEFLATE_APIS
191  
192 0 int mz_deflateInit(mz_streamp pStream, int level)
193 {
194 0 return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY);
195 }
196  
197 0 int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
198 {
199 tdefl_compressor *pComp;
200 0 mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
201  
202 0 ▶ if (!pStream)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream) 0 0 0
203 0 return MZ_STREAM_ERROR;
204 0 ▶ if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
Branch: 5 branches
BranchTrueFalseTotal
if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) 0 0 0
if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) 0 0 0
if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) 0 0 0
if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) 0 0 0
if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) 0 0 0
205 0 return MZ_PARAM_ERROR;
206  
207 0 pStream->data_type = 0;
208 0 pStream->adler = MZ_ADLER32_INIT;
209 0 pStream->msg = NULL;
210 0 pStream->reserved = 0;
211 0 pStream->total_in = 0;
212 0 pStream->total_out = 0;
213 0 ▶ if (!pStream->zalloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream->zalloc) 0 0 0
214 0 pStream->zalloc = miniz_def_alloc_func;
215 0 ▶ if (!pStream->zfree)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream->zfree) 0 0 0
216 0 pStream->zfree = miniz_def_free_func;
217  
218 0 pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
219 0 ▶ if (!pComp)
Branch: 1 branch
BranchTrueFalseTotal
if (!pComp) 0 0 0
220 0 return MZ_MEM_ERROR;
221  
222 0 pStream->state = (struct mz_internal_state *)pComp;
223  
224 0 ▶ if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
Branch: 1 branch
BranchTrueFalseTotal
if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) 0 0 0
225 {
226 0 mz_deflateEnd(pStream);
227 0 return MZ_PARAM_ERROR;
228 }
229  
230 0 return MZ_OK;
231 }
232  
233 0 int mz_deflateReset(mz_streamp pStream)
234 {
235 0 ▶ if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) 0 0 0
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) 0 0 0
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) 0 0 0
if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) 0 0 0
236 0 return MZ_STREAM_ERROR;
237 0 pStream->total_in = pStream->total_out = 0;
238 0 tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
239 0 return MZ_OK;
240 }
241  
242 0 int mz_deflate(mz_streamp pStream, int flush)
243 {
244 size_t in_bytes, out_bytes;
245 mz_ulong orig_total_in, orig_total_out;
246 0 int mz_status = MZ_OK;
247  
248 0 ▶ if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out))
Branch: 5 branches
BranchTrueFalseTotal
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) 0 0 0
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) 0 0 0
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) 0 0 0
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) 0 0 0
if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) 0 0 0
249 0 return MZ_STREAM_ERROR;
250 0 ▶ if (!pStream->avail_out)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream->avail_out) 0 0 0
251 0 return MZ_BUF_ERROR;
252  
253 0 ▶ if (flush == MZ_PARTIAL_FLUSH)
Branch: 1 branch
BranchTrueFalseTotal
if (flush == MZ_PARTIAL_FLUSH) 0 0 0
254 0 flush = MZ_SYNC_FLUSH;
255  
256 0 ▶ if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE) 0 0 0
257 0 ▶ return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
Branch: 1 branch
BranchTrueFalseTotal
return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; 0 0 0
258  
259 0 orig_total_in = pStream->total_in;
260 0 orig_total_out = pStream->total_out;
261 for (;;)
262 0 {
263 tdefl_status defl_status;
264 0 in_bytes = pStream->avail_in;
265 0 out_bytes = pStream->avail_out;
266  
267 0 defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
268 0 pStream->next_in += (mz_uint)in_bytes;
269 0 pStream->avail_in -= (mz_uint)in_bytes;
270 0 pStream->total_in += (mz_uint)in_bytes;
271 0 pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
272  
273 0 pStream->next_out += (mz_uint)out_bytes;
274 0 pStream->avail_out -= (mz_uint)out_bytes;
275 0 pStream->total_out += (mz_uint)out_bytes;
276  
277 0 ▶ if (defl_status < 0)
Branch: 1 branch
BranchTrueFalseTotal
if (defl_status < 0) 0 0 0
278 {
279 0 mz_status = MZ_STREAM_ERROR;
280 0 break;
281 }
282 0 ▶ else if (defl_status == TDEFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
else if (defl_status == TDEFL_STATUS_DONE) 0 0 0
283 {
284 0 mz_status = MZ_STREAM_END;
285 0 break;
286 }
287 0 ▶ else if (!pStream->avail_out)
Branch: 1 branch
BranchTrueFalseTotal
else if (!pStream->avail_out) 0 0 0
288 0 break;
289 0 ▶ else if ((!pStream->avail_in) && (flush != MZ_FINISH))
Branch: 2 branches
BranchTrueFalseTotal
else if ((!pStream->avail_in) && (flush != MZ_FINISH)) 0 0 0
else if ((!pStream->avail_in) && (flush != MZ_FINISH)) 0 0 0
290 {
291 0 ▶ if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
Branch: 3 branches
BranchTrueFalseTotal
if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) 0 0 0
if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) 0 0 0
if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) 0 0 0
292 break;
293 0 return MZ_BUF_ERROR; /* Can't make forward progress without some input.
294 */
295 }
296 }
297 0 return mz_status;
298 }
299  
300 0 int mz_deflateEnd(mz_streamp pStream)
301 {
302 0 ▶ if (!pStream)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream) 0 0 0
303 0 return MZ_STREAM_ERROR;
304 0 ▶ if (pStream->state)
Branch: 1 branch
BranchTrueFalseTotal
if (pStream->state) 0 0 0
305 {
306 0 pStream->zfree(pStream->opaque, pStream->state);
307 0 pStream->state = NULL;
308 }
309 0 return MZ_OK;
310 }
311  
312 0 mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
313 {
314 (void)pStream;
315 /* This is really over conservative. (And lame, but it's actually pretty tricky to compute a true upper bound given the way tdefl's blocking works.) */
316 0 return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
317 }
318  
319 0 int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
320 {
321 int status;
322 mz_stream stream;
323 0 memset(&stream, 0, sizeof(stream));
324  
325 /* In case mz_ulong is 64-bits (argh I hate longs). */
326 0 ▶ if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU)
Branch: 1 branch
BranchTrueFalseTotal
if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU) 0 0 0
327 0 return MZ_PARAM_ERROR;
328  
329 0 stream.next_in = pSource;
330 0 stream.avail_in = (mz_uint32)source_len;
331 0 stream.next_out = pDest;
332 0 stream.avail_out = (mz_uint32)*pDest_len;
333  
334 0 status = mz_deflateInit(&stream, level);
335 0 ▶ if (status != MZ_OK)
Branch: 1 branch
BranchTrueFalseTotal
if (status != MZ_OK) 0 0 0
336 0 return status;
337  
338 0 status = mz_deflate(&stream, MZ_FINISH);
339 0 ▶ if (status != MZ_STREAM_END)
Branch: 1 branch
BranchTrueFalseTotal
if (status != MZ_STREAM_END) 0 0 0
340 {
341 0 mz_deflateEnd(&stream);
342 0 ▶ return (status == MZ_OK) ? MZ_BUF_ERROR : status;
Branch: 1 branch
BranchTrueFalseTotal
return (status == MZ_OK) ? MZ_BUF_ERROR : status; 0 0 0
343 }
344  
345 0 *pDest_len = stream.total_out;
346 0 return mz_deflateEnd(&stream);
347 }
348  
349 0 int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
350 {
351 0 return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
352 }
353  
354 0 mz_ulong mz_compressBound(mz_ulong source_len)
355 {
356 0 return mz_deflateBound(NULL, source_len);
357 }
358  
359 #endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
360  
361 #ifndef MINIZ_NO_INFLATE_APIS
362  
363 typedef struct
364 {
365 tinfl_decompressor m_decomp;
366 mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed;
367 int m_window_bits;
368 mz_uint8 m_dict[TINFL_LZ_DICT_SIZE];
369 tinfl_status m_last_status;
370 } inflate_state;
371  
372 0 int mz_inflateInit2(mz_streamp pStream, int window_bits)
373 {
374 inflate_state *pDecomp;
375 0 ▶ if (!pStream)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream) 0 0 0
376 0 return MZ_STREAM_ERROR;
377 0 ▶ if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
Branch: 2 branches
BranchTrueFalseTotal
if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) 0 0 0
if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) 0 0 0
378 0 return MZ_PARAM_ERROR;
379  
380 0 pStream->data_type = 0;
381 0 pStream->adler = 0;
382 0 pStream->msg = NULL;
383 0 pStream->total_in = 0;
384 0 pStream->total_out = 0;
385 0 pStream->reserved = 0;
386 0 ▶ if (!pStream->zalloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream->zalloc) 0 0 0
387 0 pStream->zalloc = miniz_def_alloc_func;
388 0 ▶ if (!pStream->zfree)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream->zfree) 0 0 0
389 0 pStream->zfree = miniz_def_free_func;
390  
391 0 pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
392 0 ▶ if (!pDecomp)
Branch: 1 branch
BranchTrueFalseTotal
if (!pDecomp) 0 0 0
393 0 return MZ_MEM_ERROR;
394  
395 0 pStream->state = (struct mz_internal_state *)pDecomp;
396  
397 0 tinfl_init(&pDecomp->m_decomp);
398 0 pDecomp->m_dict_ofs = 0;
399 0 pDecomp->m_dict_avail = 0;
400 0 pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
401 0 pDecomp->m_first_call = 1;
402 0 pDecomp->m_has_flushed = 0;
403 0 pDecomp->m_window_bits = window_bits;
404  
405 0 return MZ_OK;
406 }
407  
408 0 int mz_inflateInit(mz_streamp pStream)
409 {
410 0 return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS);
411 }
412  
413 0 int mz_inflateReset(mz_streamp pStream)
414 {
415 inflate_state *pDecomp;
416 0 ▶ if (!pStream)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream) 0 0 0
417 0 return MZ_STREAM_ERROR;
418  
419 0 pStream->data_type = 0;
420 0 pStream->adler = 0;
421 0 pStream->msg = NULL;
422 0 pStream->total_in = 0;
423 0 pStream->total_out = 0;
424 0 pStream->reserved = 0;
425  
426 0 pDecomp = (inflate_state *)pStream->state;
427  
428 0 tinfl_init(&pDecomp->m_decomp);
429 0 pDecomp->m_dict_ofs = 0;
430 0 pDecomp->m_dict_avail = 0;
431 0 pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT;
432 0 pDecomp->m_first_call = 1;
433 0 pDecomp->m_has_flushed = 0;
434 /* pDecomp->m_window_bits = window_bits */;
435  
436 0 return MZ_OK;
437 }
438  
439 0 int mz_inflate(mz_streamp pStream, int flush)
440 {
441 inflate_state *pState;
442 0 mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
443 size_t in_bytes, out_bytes, orig_avail_in;
444 tinfl_status status;
445  
446 0 ▶ if ((!pStream) || (!pStream->state))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pStream) || (!pStream->state)) 0 0 0
if ((!pStream) || (!pStream->state)) 0 0 0
447 0 return MZ_STREAM_ERROR;
448 0 ▶ if (flush == MZ_PARTIAL_FLUSH)
Branch: 1 branch
BranchTrueFalseTotal
if (flush == MZ_PARTIAL_FLUSH) 0 0 0
449 0 flush = MZ_SYNC_FLUSH;
450 0 ▶ if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH))
Branch: 3 branches
BranchTrueFalseTotal
if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) 0 0 0
if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) 0 0 0
if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) 0 0 0
451 0 return MZ_STREAM_ERROR;
452  
453 0 pState = (inflate_state *)pStream->state;
454 0 ▶ if (pState->m_window_bits > 0)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_window_bits > 0) 0 0 0
455 0 decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
456 0 orig_avail_in = pStream->avail_in;
457  
458 0 first_call = pState->m_first_call;
459 0 pState->m_first_call = 0;
460 0 ▶ if (pState->m_last_status < 0)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_last_status < 0) 0 0 0
461 0 return MZ_DATA_ERROR;
462  
463 0 ▶ if (pState->m_has_flushed && (flush != MZ_FINISH))
Branch: 2 branches
BranchTrueFalseTotal
if (pState->m_has_flushed && (flush != MZ_FINISH)) 0 0 0
if (pState->m_has_flushed && (flush != MZ_FINISH)) 0 0 0
464 0 return MZ_STREAM_ERROR;
465 0 pState->m_has_flushed |= (flush == MZ_FINISH);
466  
467 0 ▶ if ((flush == MZ_FINISH) && (first_call))
Branch: 2 branches
BranchTrueFalseTotal
if ((flush == MZ_FINISH) && (first_call)) 0 0 0
if ((flush == MZ_FINISH) && (first_call)) 0 0 0
468 {
469 /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */
470 0 decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
471 0 in_bytes = pStream->avail_in;
472 0 out_bytes = pStream->avail_out;
473 0 status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
474 0 pState->m_last_status = status;
475 0 pStream->next_in += (mz_uint)in_bytes;
476 0 pStream->avail_in -= (mz_uint)in_bytes;
477 0 pStream->total_in += (mz_uint)in_bytes;
478 0 pStream->adler = tinfl_get_adler32(&pState->m_decomp);
479 0 pStream->next_out += (mz_uint)out_bytes;
480 0 pStream->avail_out -= (mz_uint)out_bytes;
481 0 pStream->total_out += (mz_uint)out_bytes;
482  
483 0 ▶ if (status < 0)
Branch: 1 branch
BranchTrueFalseTotal
if (status < 0) 0 0 0
484 0 return MZ_DATA_ERROR;
485 0 ▶ else if (status != TINFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
else if (status != TINFL_STATUS_DONE) 0 0 0
486 {
487 0 pState->m_last_status = TINFL_STATUS_FAILED;
488 0 return MZ_BUF_ERROR;
489 }
490 0 return MZ_STREAM_END;
491 }
492 /* flush != MZ_FINISH then we must assume there's more input. */
493 0 ▶ if (flush != MZ_FINISH)
Branch: 1 branch
BranchTrueFalseTotal
if (flush != MZ_FINISH) 0 0 0
494 0 decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
495  
496 0 ▶ if (pState->m_dict_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_dict_avail) 0 0 0
497 {
498 0 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
499 0 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
500 0 pStream->next_out += n;
501 0 pStream->avail_out -= n;
502 0 pStream->total_out += n;
503 0 pState->m_dict_avail -= n;
504 0 pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
505 0 ▶ return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
Branch: 2 branches
BranchTrueFalseTotal
return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; 0 0 0
return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; 0 0 0
506 }
507  
508 for (;;)
509 {
510 0 in_bytes = pStream->avail_in;
511 0 out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
512  
513 0 status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags);
514 0 pState->m_last_status = status;
515  
516 0 pStream->next_in += (mz_uint)in_bytes;
517 0 pStream->avail_in -= (mz_uint)in_bytes;
518 0 pStream->total_in += (mz_uint)in_bytes;
519 0 pStream->adler = tinfl_get_adler32(&pState->m_decomp);
520  
521 0 pState->m_dict_avail = (mz_uint)out_bytes;
522  
523 0 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
524 0 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
525 0 pStream->next_out += n;
526 0 pStream->avail_out -= n;
527 0 pStream->total_out += n;
528 0 pState->m_dict_avail -= n;
529 0 pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
530  
531 0 ▶ if (status < 0)
Branch: 1 branch
BranchTrueFalseTotal
if (status < 0) 0 0 0
532 0 return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */
533 0 ▶ else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
Branch: 2 branches
BranchTrueFalseTotal
else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) 0 0 0
else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) 0 0 0
534 0 return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */
535 0 ▶ else if (flush == MZ_FINISH)
Branch: 1 branch
BranchTrueFalseTotal
else if (flush == MZ_FINISH) 0 0 0
536 {
537 /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */
538 0 ▶ if (status == TINFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (status == TINFL_STATUS_DONE) 0 0 0
539 0 ▶ return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
Branch: 1 branch
BranchTrueFalseTotal
return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; 0 0 0
540 /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's at least 1 more byte on the way. If there's no more room left in the output buffer then something is wrong. */
541 0 ▶ else if (!pStream->avail_out)
Branch: 1 branch
BranchTrueFalseTotal
else if (!pStream->avail_out) 0 0 0
542 0 return MZ_BUF_ERROR;
543 }
544 0 ▶ else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
Branch: 4 branches
BranchTrueFalseTotal
else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) 0 0 0
else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) 0 0 0
else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) 0 0 0
else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) 0 0 0
545 break;
546 }
547  
548 0 ▶ return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
Branch: 2 branches
BranchTrueFalseTotal
return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; 0 0 0
return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; 0 0 0
549 }
550  
551 0 int mz_inflateEnd(mz_streamp pStream)
552 {
553 0 ▶ if (!pStream)
Branch: 1 branch
BranchTrueFalseTotal
if (!pStream) 0 0 0
554 0 return MZ_STREAM_ERROR;
555 0 ▶ if (pStream->state)
Branch: 1 branch
BranchTrueFalseTotal
if (pStream->state) 0 0 0
556 {
557 0 pStream->zfree(pStream->opaque, pStream->state);
558 0 pStream->state = NULL;
559 }
560 0 return MZ_OK;
561 }
562 0 int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len)
563 {
564 mz_stream stream;
565 int status;
566 0 memset(&stream, 0, sizeof(stream));
567  
568 /* In case mz_ulong is 64-bits (argh I hate longs). */
569 0 ▶ if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU)
Branch: 1 branch
BranchTrueFalseTotal
if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU) 0 0 0
570 0 return MZ_PARAM_ERROR;
571  
572 0 stream.next_in = pSource;
573 0 stream.avail_in = (mz_uint32)*pSource_len;
574 0 stream.next_out = pDest;
575 0 stream.avail_out = (mz_uint32)*pDest_len;
576  
577 0 status = mz_inflateInit(&stream);
578 0 ▶ if (status != MZ_OK)
Branch: 1 branch
BranchTrueFalseTotal
if (status != MZ_OK) 0 0 0
579 0 return status;
580  
581 0 status = mz_inflate(&stream, MZ_FINISH);
582 0 *pSource_len = *pSource_len - stream.avail_in;
583 0 ▶ if (status != MZ_STREAM_END)
Branch: 1 branch
BranchTrueFalseTotal
if (status != MZ_STREAM_END) 0 0 0
584 {
585 0 mz_inflateEnd(&stream);
586 0 ▶ return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
Branch: 2 branches
BranchTrueFalseTotal
return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status; 0 0 0
return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status; 0 0 0
587 }
588 0 *pDest_len = stream.total_out;
589  
590 0 return mz_inflateEnd(&stream);
591 }
592  
593 0 int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len)
594 {
595 0 return mz_uncompress2(pDest, pDest_len, pSource, &source_len);
596 }
597  
598 #endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
599  
600 0 const char *mz_error(int err)
601 {
602 static struct
603 {
604 int m_err;
605 const char *m_pDesc;
606 } s_error_descs[] = {
607 { MZ_OK, "" }, { MZ_STREAM_END, "stream end" }, { MZ_NEED_DICT, "need dictionary" }, { MZ_ERRNO, "file error" }, { MZ_STREAM_ERROR, "stream error" }, { MZ_DATA_ERROR, "data error" }, { MZ_MEM_ERROR, "out of memory" }, { MZ_BUF_ERROR, "buf error" }, { MZ_VERSION_ERROR, "version error" }, { MZ_PARAM_ERROR, "parameter error" }
608 };
609 mz_uint i;
610 0 ▶ for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) 0 0 0
611 0 ▶ if (s_error_descs[i].m_err == err)
Branch: 1 branch
BranchTrueFalseTotal
if (s_error_descs[i].m_err == err) 0 0 0
612 0 return s_error_descs[i].m_pDesc;
613 0 return NULL;
614 }
615  
616 #endif /*MINIZ_NO_ZLIB_APIS */
617  
618 #ifdef __cplusplus
619 }
620 #endif
621  
622 /*
623 This is free and unencumbered software released into the public domain.
624  
625 Anyone is free to copy, modify, publish, use, compile, sell, or
626 distribute this software, either in source code form or as a compiled
627 binary, for any purpose, commercial or non-commercial, and by any
628 means.
629  
630 In jurisdictions that recognize copyright laws, the author or authors
631 of this software dedicate any and all copyright interest in the
632 software to the public domain. We make this dedication for the benefit
633 of the public at large and to the detriment of our heirs and
634 successors. We intend this dedication to be an overt act of
635 relinquishment in perpetuity of all present and future rights to this
636 software under copyright law.
637  
638 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
639 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
640 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
641 IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
642 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
643 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
644 OTHER DEALINGS IN THE SOFTWARE.
645  
646 For more information, please refer to <http://unlicense.org/>
647 */
648 /**************************************************************************
649 *
650 * Copyright 2013-2014 RAD Game Tools and Valve Software
651 * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
652 * All Rights Reserved.
653 *
654 * Permission is hereby granted, free of charge, to any person obtaining a copy
655 * of this software and associated documentation files (the "Software"), to deal
656 * in the Software without restriction, including without limitation the rights
657 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
658 * copies of the Software, and to permit persons to whom the Software is
659 * furnished to do so, subject to the following conditions:
660 *
661 * The above copyright notice and this permission notice shall be included in
662 * all copies or substantial portions of the Software.
663 *
664 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
665 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
666 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
667 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
668 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
669 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
670 * THE SOFTWARE.
671 *
672 **************************************************************************/
673  
674  
675  
676 #ifndef MINIZ_NO_DEFLATE_APIS
677  
678 #ifdef __cplusplus
679 extern "C"
680 {
681 #endif
682  
683 /* ------------------- Low-level Compression (independent from all decompression API's) */
684  
685 /* Purposely making these tables static for faster init and thread safety. */
686 static const mz_uint16 s_tdefl_len_sym[256] = {
687 257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 272,
688 273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, 276, 276, 276,
689 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278,
690 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
691 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281,
692 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282,
693 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283,
694 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 285
695 };
696  
697 static const mz_uint8 s_tdefl_len_extra[256] = {
698 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
699 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
700 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
701 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0
702 };
703  
704 static const mz_uint8 s_tdefl_small_dist_sym[512] = {
705 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,
706 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13,
707 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
708 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
709 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
710 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
711 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
712 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
713 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
714 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
715 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
716 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
717 };
718  
719 static const mz_uint8 s_tdefl_small_dist_extra[512] = {
720 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
721 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
722 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
723 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
724 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
725 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
726 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
727 7, 7, 7, 7, 7, 7, 7, 7
728 };
729  
730 static const mz_uint8 s_tdefl_large_dist_sym[128] = {
731 0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
732 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
733 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
734 };
735  
736 static const mz_uint8 s_tdefl_large_dist_extra[128] = {
737 0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
738 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
739 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13
740 };
741  
742 /* Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values. */
743 typedef struct
744 {
745 mz_uint16 m_key, m_sym_index;
746 } tdefl_sym_freq;
747 0 static tdefl_sym_freq *tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1)
748 {
749 0 mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2];
750 0 tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1;
751 0 MZ_CLEAR_ARR(hist);
752 0 ▶ for (i = 0; i < num_syms; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < num_syms; i++) 0 0 0
753 {
754 0 mz_uint freq = pSyms0[i].m_key;
755 0 hist[freq & 0xFF]++;
756 0 hist[256 + ((freq >> 8) & 0xFF)]++;
757 }
758 0 ▶ while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256]))
Branch: 2 branches
BranchTrueFalseTotal
while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) 0 0 0
while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) 0 0 0
759 0 total_passes--;
760 0 ▶ for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8)
Branch: 1 branch
BranchTrueFalseTotal
for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) 0 0 0
761 {
762 0 const mz_uint32 *pHist = &hist[pass << 8];
763 0 mz_uint offsets[256], cur_ofs = 0;
764 0 ▶ for (i = 0; i < 256; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 256; i++) 0 0 0
765 {
766 0 offsets[i] = cur_ofs;
767 0 cur_ofs += pHist[i];
768 }
769 0 ▶ for (i = 0; i < num_syms; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < num_syms; i++) 0 0 0
770 0 pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i];
771 {
772 0 tdefl_sym_freq *t = pCur_syms;
773 0 pCur_syms = pNew_syms;
774 0 pNew_syms = t;
775 }
776 }
777 0 return pCur_syms;
778 }
779  
780 /* tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. */
781 0 static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n)
782 {
783 int root, leaf, next, avbl, used, dpth;
784 0 ▶ if (n == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (n == 0) 0 0 0
785 0 return;
786 0 ▶ else if (n == 1)
Branch: 1 branch
BranchTrueFalseTotal
else if (n == 1) 0 0 0
787 {
788 0 A[0].m_key = 1;
789 0 return;
790 }
791 0 A[0].m_key += A[1].m_key;
792 0 root = 0;
793 0 leaf = 2;
794 0 ▶ for (next = 1; next < n - 1; next++)
Branch: 1 branch
BranchTrueFalseTotal
for (next = 1; next < n - 1; next++) 0 0 0
795 {
796 0 ▶ if (leaf >= n || A[root].m_key < A[leaf].m_key)
Branch: 2 branches
BranchTrueFalseTotal
if (leaf >= n || A[root].m_key < A[leaf].m_key) 0 0 0
if (leaf >= n || A[root].m_key < A[leaf].m_key) 0 0 0
797 {
798 0 A[next].m_key = A[root].m_key;
799 0 A[root++].m_key = (mz_uint16)next;
800 }
801 else
802 0 A[next].m_key = A[leaf++].m_key;
803 0 ▶ if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key))
Branch: 3 branches
BranchTrueFalseTotal
if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) 0 0 0
if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) 0 0 0
if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) 0 0 0
804 {
805 0 A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key);
806 0 A[root++].m_key = (mz_uint16)next;
807 }
808 else
809 0 A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key);
810 }
811 0 A[n - 2].m_key = 0;
812 0 ▶ for (next = n - 3; next >= 0; next--)
Branch: 1 branch
BranchTrueFalseTotal
for (next = n - 3; next >= 0; next--) 0 0 0
813 0 A[next].m_key = A[A[next].m_key].m_key + 1;
814 0 avbl = 1;
815 0 used = dpth = 0;
816 0 root = n - 2;
817 0 next = n - 1;
818 0 ▶ while (avbl > 0)
Branch: 1 branch
BranchTrueFalseTotal
while (avbl > 0) 0 0 0
819 {
820 0 ▶ while (root >= 0 && (int)A[root].m_key == dpth)
Branch: 2 branches
BranchTrueFalseTotal
while (root >= 0 && (int)A[root].m_key == dpth) 0 0 0
while (root >= 0 && (int)A[root].m_key == dpth) 0 0 0
821 {
822 0 used++;
823 0 root--;
824 }
825 0 ▶ while (avbl > used)
Branch: 1 branch
BranchTrueFalseTotal
while (avbl > used) 0 0 0
826 {
827 0 A[next--].m_key = (mz_uint16)(dpth);
828 0 avbl--;
829 }
830 0 avbl = 2 * used;
831 0 dpth++;
832 0 used = 0;
833 }
834 }
835  
836 /* Limits canonical Huffman code table's max code size. */
837 enum
838 {
839 TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32
840 };
841 0 static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
842 {
843 int i;
844 0 mz_uint32 total = 0;
845 0 ▶ if (code_list_len <= 1)
Branch: 1 branch
BranchTrueFalseTotal
if (code_list_len <= 1) 0 0 0
846 0 return;
847 0 ▶ for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) 0 0 0
848 0 pNum_codes[max_code_size] += pNum_codes[i];
849 0 ▶ for (i = max_code_size; i > 0; i--)
Branch: 1 branch
BranchTrueFalseTotal
for (i = max_code_size; i > 0; i--) 0 0 0
850 0 total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
851 0 ▶ while (total != (1UL << max_code_size))
Branch: 1 branch
BranchTrueFalseTotal
while (total != (1UL << max_code_size)) 0 0 0
852 {
853 0 pNum_codes[max_code_size]--;
854 0 ▶ for (i = max_code_size - 1; i > 0; i--)
Branch: 1 branch
BranchTrueFalseTotal
for (i = max_code_size - 1; i > 0; i--) 0 0 0
855 0 ▶ if (pNum_codes[i])
Branch: 1 branch
BranchTrueFalseTotal
if (pNum_codes[i]) 0 0 0
856 {
857 0 pNum_codes[i]--;
858 0 pNum_codes[i + 1] += 2;
859 0 break;
860 }
861 0 total--;
862 }
863 }
864  
865 0 static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table)
866 {
867 int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE];
868 mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1];
869 0 MZ_CLEAR_ARR(num_codes);
870 0 ▶ if (static_table)
Branch: 1 branch
BranchTrueFalseTotal
if (static_table) 0 0 0
871 {
872 0 ▶ for (i = 0; i < table_len; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < table_len; i++) 0 0 0
873 0 num_codes[d->m_huff_code_sizes[table_num][i]]++;
874 }
875 else
876 {
877 tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms;
878 0 int num_used_syms = 0;
879 0 const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0];
880 0 ▶ for (i = 0; i < table_len; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < table_len; i++) 0 0 0
881 0 ▶ if (pSym_count[i])
Branch: 1 branch
BranchTrueFalseTotal
if (pSym_count[i]) 0 0 0
882 {
883 0 syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i];
884 0 syms0[num_used_syms++].m_sym_index = (mz_uint16)i;
885 }
886  
887 0 pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1);
888 0 tdefl_calculate_minimum_redundancy(pSyms, num_used_syms);
889  
890 0 ▶ for (i = 0; i < num_used_syms; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < num_used_syms; i++) 0 0 0
891 0 num_codes[pSyms[i].m_key]++;
892  
893 0 tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit);
894  
895 0 MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]);
896 0 MZ_CLEAR_ARR(d->m_huff_codes[table_num]);
897 0 ▶ for (i = 1, j = num_used_syms; i <= code_size_limit; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 1, j = num_used_syms; i <= code_size_limit; i++) 0 0 0
898 0 ▶ for (l = num_codes[i]; l > 0; l--)
Branch: 1 branch
BranchTrueFalseTotal
for (l = num_codes[i]; l > 0; l--) 0 0 0
899 0 d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i);
900 }
901  
902 0 next_code[1] = 0;
903 0 ▶ for (j = 0, i = 2; i <= code_size_limit; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0, i = 2; i <= code_size_limit; i++) 0 0 0
904 0 next_code[i] = j = ((j + num_codes[i - 1]) << 1);
905  
906 0 ▶ for (i = 0; i < table_len; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < table_len; i++) 0 0 0
907 {
908 0 mz_uint rev_code = 0, code, code_size;
909 0 ▶ if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) 0 0 0
910 0 continue;
911 0 code = next_code[code_size]++;
912 0 ▶ for (l = code_size; l > 0; l--, code >>= 1)
Branch: 1 branch
BranchTrueFalseTotal
for (l = code_size; l > 0; l--, code >>= 1) 0 0 0
913 0 rev_code = (rev_code << 1) | (code & 1);
914 0 d->m_huff_codes[table_num][i] = (mz_uint16)rev_code;
915 }
916 0 }
917  
918 #define TDEFL_PUT_BITS(b, l) \
919 do \
920 { \
921 mz_uint bits = b; \
922 mz_uint len = l; \
923 MZ_ASSERT(bits <= ((1U << len) - 1U)); \
924 d->m_bit_buffer |= (bits << d->m_bits_in); \
925 d->m_bits_in += len; \
926 while (d->m_bits_in >= 8) \
927 { \
928 if (d->m_pOutput_buf < d->m_pOutput_buf_end) \
929 *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \
930 d->m_bit_buffer >>= 8; \
931 d->m_bits_in -= 8; \
932 } \
933 } \
934 MZ_MACRO_END
935  
936 #define TDEFL_RLE_PREV_CODE_SIZE() \
937 { \
938 if (rle_repeat_count) \
939 { \
940 if (rle_repeat_count < 3) \
941 { \
942 d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \
943 while (rle_repeat_count--) \
944 packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \
945 } \
946 else \
947 { \
948 d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \
949 packed_code_sizes[num_packed_code_sizes++] = 16; \
950 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \
951 } \
952 rle_repeat_count = 0; \
953 } \
954 }
955  
956 #define TDEFL_RLE_ZERO_CODE_SIZE() \
957 { \
958 if (rle_z_count) \
959 { \
960 if (rle_z_count < 3) \
961 { \
962 d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \
963 while (rle_z_count--) \
964 packed_code_sizes[num_packed_code_sizes++] = 0; \
965 } \
966 else if (rle_z_count <= 10) \
967 { \
968 d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \
969 packed_code_sizes[num_packed_code_sizes++] = 17; \
970 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \
971 } \
972 else \
973 { \
974 d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \
975 packed_code_sizes[num_packed_code_sizes++] = 18; \
976 packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \
977 } \
978 rle_z_count = 0; \
979 } \
980 }
981  
982 static const mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
983  
984 0 static void tdefl_start_dynamic_block(tdefl_compressor *d)
985 {
986 int num_lit_codes, num_dist_codes, num_bit_lengths;
987 mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index;
988 0 mz_uint8 code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], prev_code_size = 0xFF;
989  
990 0 d->m_huff_count[0][256] = 1;
991  
992 0 tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE);
993 0 tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE);
994  
995 0 ▶ for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--)
Branch: 1 branch
BranchTrueFalseTotal
for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) 0 0 0
996 0 ▶ if (d->m_huff_code_sizes[0][num_lit_codes - 1])
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_huff_code_sizes[0][num_lit_codes - 1]) 0 0 0
997 0 break;
998 0 ▶ for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--)
Branch: 1 branch
BranchTrueFalseTotal
for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) 0 0 0
999 0 ▶ if (d->m_huff_code_sizes[1][num_dist_codes - 1])
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_huff_code_sizes[1][num_dist_codes - 1]) 0 0 0
1000 0 break;
1001  
1002 0 memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes);
1003 0 memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes);
1004 0 total_code_sizes_to_pack = num_lit_codes + num_dist_codes;
1005 0 num_packed_code_sizes = 0;
1006 0 rle_z_count = 0;
1007 0 rle_repeat_count = 0;
1008  
1009 0 memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2);
1010 0 ▶ for (i = 0; i < total_code_sizes_to_pack; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < total_code_sizes_to_pack; i++) 0 0 0
1011 {
1012 0 mz_uint8 code_size = code_sizes_to_pack[i];
1013 0 ▶ if (!code_size)
Branch: 1 branch
BranchTrueFalseTotal
if (!code_size) 0 0 0
1014 {
1015 0 ▶ TDEFL_RLE_PREV_CODE_SIZE();
Branch: 3 branches
BranchTrueFalseTotal
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
1016 0 ▶ if (++rle_z_count == 138)
Branch: 1 branch
BranchTrueFalseTotal
if (++rle_z_count == 138) 0 0 0
1017 {
1018 0 ▶ TDEFL_RLE_ZERO_CODE_SIZE();
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
1019 }
1020 }
1021 else
1022 {
1023 0 ▶ TDEFL_RLE_ZERO_CODE_SIZE();
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
1024 0 ▶ if (code_size != prev_code_size)
Branch: 1 branch
BranchTrueFalseTotal
if (code_size != prev_code_size) 0 0 0
1025 {
1026 0 ▶ TDEFL_RLE_PREV_CODE_SIZE();
Branch: 3 branches
BranchTrueFalseTotal
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
1027 0 d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1);
1028 0 packed_code_sizes[num_packed_code_sizes++] = code_size;
1029 }
1030 0 ▶ else if (++rle_repeat_count == 6)
Branch: 1 branch
BranchTrueFalseTotal
else if (++rle_repeat_count == 6) 0 0 0
1031 {
1032 0 ▶ TDEFL_RLE_PREV_CODE_SIZE();
Branch: 3 branches
BranchTrueFalseTotal
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
1033 }
1034 }
1035 0 prev_code_size = code_size;
1036 }
1037 0 ▶ if (rle_repeat_count)
Branch: 1 branch
BranchTrueFalseTotal
if (rle_repeat_count) 0 0 0
1038 {
1039 0 ▶ TDEFL_RLE_PREV_CODE_SIZE();
Branch: 3 branches
BranchTrueFalseTotal
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
TDEFL_RLE_PREV_CODE_SIZE(); 0 0 0
1040 }
1041 else
1042 {
1043 0 ▶ TDEFL_RLE_ZERO_CODE_SIZE();
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
TDEFL_RLE_ZERO_CODE_SIZE(); 0 0 0
1044 }
1045  
1046 0 tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE);
1047  
1048 0 ▶ TDEFL_PUT_BITS(2, 2);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(2, 2); 0 0 0
TDEFL_PUT_BITS(2, 2); 0 0 0
1049  
1050 0 ▶ TDEFL_PUT_BITS(num_lit_codes - 257, 5);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(num_lit_codes - 257, 5); 0 0 0
TDEFL_PUT_BITS(num_lit_codes - 257, 5); 0 0 0
1051 0 ▶ TDEFL_PUT_BITS(num_dist_codes - 1, 5);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(num_dist_codes - 1, 5); 0 0 0
TDEFL_PUT_BITS(num_dist_codes - 1, 5); 0 0 0
1052  
1053 0 ▶ for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--)
Branch: 1 branch
BranchTrueFalseTotal
for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) 0 0 0
1054 0 ▶ if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]])
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) 0 0 0
1055 0 break;
1056 0 num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1));
1057 0 ▶ TDEFL_PUT_BITS(num_bit_lengths - 4, 4);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(num_bit_lengths - 4, 4); 0 0 0
TDEFL_PUT_BITS(num_bit_lengths - 4, 4); 0 0 0
1058 0 ▶ for (i = 0; (int)i < num_bit_lengths; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; (int)i < num_bit_lengths; i++) 0 0 0
1059 0 ▶ TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); 0 0 0
TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); 0 0 0
1060  
1061 0 ▶ for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;)
Branch: 1 branch
BranchTrueFalseTotal
for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;) 0 0 0
1062 {
1063 0 mz_uint code = packed_code_sizes[packed_code_sizes_index++];
1064 MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2);
1065 0 ▶ TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); 0 0 0
TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); 0 0 0
1066 0 ▶ if (code >= 16)
Branch: 1 branch
BranchTrueFalseTotal
if (code >= 16) 0 0 0
1067 0 ▶ TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); 0 0 0
TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); 0 0 0
1068 }
1069 0 }
1070  
1071 0 static void tdefl_start_static_block(tdefl_compressor *d)
1072 {
1073 mz_uint i;
1074 0 mz_uint8 *p = &d->m_huff_code_sizes[0][0];
1075  
1076 0 ▶ for (i = 0; i <= 143; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i <= 143; ++i) 0 0 0
1077 0 *p++ = 8;
1078 0 ▶ for (; i <= 255; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 255; ++i) 0 0 0
1079 0 *p++ = 9;
1080 0 ▶ for (; i <= 279; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 279; ++i) 0 0 0
1081 0 *p++ = 7;
1082 0 ▶ for (; i <= 287; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 287; ++i) 0 0 0
1083 0 *p++ = 8;
1084  
1085 0 memset(d->m_huff_code_sizes[1], 5, 32);
1086  
1087 0 tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
1088 0 tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);
1089  
1090 0 ▶ TDEFL_PUT_BITS(1, 2);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(1, 2); 0 0 0
TDEFL_PUT_BITS(1, 2); 0 0 0
1091 0 }
1092  
1093 static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
1094  
1095 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS
1096 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
1097 {
1098 mz_uint flags;
1099 mz_uint8 *pLZ_codes;
1100 mz_uint8 *pOutput_buf = d->m_pOutput_buf;
1101 mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf;
1102 mz_uint64 bit_buffer = d->m_bit_buffer;
1103 mz_uint bits_in = d->m_bits_in;
1104  
1105 #define TDEFL_PUT_BITS_FAST(b, l) \
1106 { \
1107 bit_buffer |= (((mz_uint64)(b)) << bits_in); \
1108 bits_in += (l); \
1109 }
1110  
1111 flags = 1;
1112 for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1)
1113 {
1114 if (flags == 1)
1115 flags = *pLZ_codes++ | 0x100;
1116  
1117 if (flags & 1)
1118 {
1119 mz_uint s0, s1, n0, n1, sym, num_extra_bits;
1120 mz_uint match_len = pLZ_codes[0];
1121 mz_uint match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));
1122 pLZ_codes += 3;
1123  
1124 MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
1125 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
1126 TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
1127  
1128 /* This sequence coaxes MSVC into using cmov's vs. jmp's. */
1129 s0 = s_tdefl_small_dist_sym[match_dist & 511];
1130 n0 = s_tdefl_small_dist_extra[match_dist & 511];
1131 s1 = s_tdefl_large_dist_sym[match_dist >> 8];
1132 n1 = s_tdefl_large_dist_extra[match_dist >> 8];
1133 sym = (match_dist < 512) ? s0 : s1;
1134 num_extra_bits = (match_dist < 512) ? n0 : n1;
1135  
1136 MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
1137 TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
1138 TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
1139 }
1140 else
1141 {
1142 mz_uint lit = *pLZ_codes++;
1143 MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
1144 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
1145  
1146 if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
1147 {
1148 flags >>= 1;
1149 lit = *pLZ_codes++;
1150 MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
1151 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
1152  
1153 if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end))
1154 {
1155 flags >>= 1;
1156 lit = *pLZ_codes++;
1157 MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
1158 TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
1159 }
1160 }
1161 }
1162  
1163 if (pOutput_buf >= d->m_pOutput_buf_end)
1164 return MZ_FALSE;
1165  
1166 memcpy(pOutput_buf, &bit_buffer, sizeof(mz_uint64));
1167 pOutput_buf += (bits_in >> 3);
1168 bit_buffer >>= (bits_in & ~7);
1169 bits_in &= 7;
1170 }
1171  
1172 #undef TDEFL_PUT_BITS_FAST
1173  
1174 d->m_pOutput_buf = pOutput_buf;
1175 d->m_bits_in = 0;
1176 d->m_bit_buffer = 0;
1177  
1178 while (bits_in)
1179 {
1180 mz_uint32 n = MZ_MIN(bits_in, 16);
1181 TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n);
1182 bit_buffer >>= n;
1183 bits_in -= n;
1184 }
1185  
1186 TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
1187  
1188 return (d->m_pOutput_buf < d->m_pOutput_buf_end);
1189 }
1190 #else
1191 0 static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d)
1192 {
1193 mz_uint flags;
1194 mz_uint8 *pLZ_codes;
1195  
1196 0 flags = 1;
1197 0 ▶ for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1)
Branch: 1 branch
BranchTrueFalseTotal
for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) 0 0 0
1198 {
1199 0 ▶ if (flags == 1)
Branch: 1 branch
BranchTrueFalseTotal
if (flags == 1) 0 0 0
1200 0 flags = *pLZ_codes++ | 0x100;
1201 0 ▶ if (flags & 1)
Branch: 1 branch
BranchTrueFalseTotal
if (flags & 1) 0 0 0
1202 {
1203 mz_uint sym, num_extra_bits;
1204 0 mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8));
1205 0 pLZ_codes += 3;
1206  
1207 MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
1208 0 ▶ TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); 0 0 0
TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); 0 0 0
1209 0 ▶ TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); 0 0 0
TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); 0 0 0
1210  
1211 0 ▶ if (match_dist < 512)
Branch: 1 branch
BranchTrueFalseTotal
if (match_dist < 512) 0 0 0
1212 {
1213 0 sym = s_tdefl_small_dist_sym[match_dist];
1214 0 num_extra_bits = s_tdefl_small_dist_extra[match_dist];
1215 }
1216 else
1217 {
1218 0 sym = s_tdefl_large_dist_sym[match_dist >> 8];
1219 0 num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8];
1220 }
1221 MZ_ASSERT(d->m_huff_code_sizes[1][sym]);
1222 0 ▶ TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); 0 0 0
TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); 0 0 0
1223 0 ▶ TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); 0 0 0
TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); 0 0 0
1224 }
1225 else
1226 {
1227 0 mz_uint lit = *pLZ_codes++;
1228 MZ_ASSERT(d->m_huff_code_sizes[0][lit]);
1229 0 ▶ TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); 0 0 0
TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); 0 0 0
1230 }
1231 }
1232  
1233 0 ▶ TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); 0 0 0
TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); 0 0 0
1234  
1235 0 return (d->m_pOutput_buf < d->m_pOutput_buf_end);
1236 }
1237 #endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS */
1238  
1239 0 static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
1240 {
1241 0 ▶ if (static_block)
Branch: 1 branch
BranchTrueFalseTotal
if (static_block) 0 0 0
1242 0 tdefl_start_static_block(d);
1243 else
1244 0 tdefl_start_dynamic_block(d);
1245 0 return tdefl_compress_lz_codes(d);
1246 }
1247  
1248 static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
1249  
1250 0 static int tdefl_flush_block(tdefl_compressor *d, int flush)
1251 {
1252 mz_uint saved_bit_buf, saved_bits_in;
1253 mz_uint8 *pSaved_output_buf;
1254 0 mz_bool comp_block_succeeded = MZ_FALSE;
1255 0 ▶ int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size;
Branch: 2 branches
BranchTrueFalseTotal
int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; 0 0 0
int n, use_raw_block = ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; 0 0 0
1256 0 ▶ mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf;
Branch: 2 branches
BranchTrueFalseTotal
mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf; 0 0 0
mz_uint8 *pOutput_buf_start = ((d->m_pPut_buf_func == NULL) && ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) : d->m_output_buf; 0 0 0
1257  
1258 0 d->m_pOutput_buf = pOutput_buf_start;
1259 0 d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16;
1260  
1261 MZ_ASSERT(!d->m_output_flush_remaining);
1262 0 d->m_output_flush_ofs = 0;
1263 0 d->m_output_flush_remaining = 0;
1264  
1265 0 *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left);
1266 0 d->m_pLZ_code_buf -= (d->m_num_flags_left == 8);
1267  
1268 0 ▶ if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index))
Branch: 2 branches
BranchTrueFalseTotal
if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) 0 0 0
if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) 0 0 0
1269 {
1270 0 const mz_uint8 cmf = 0x78;
1271 0 mz_uint8 flg, flevel = 3;
1272 0 mz_uint header, i, mz_un = sizeof(s_tdefl_num_probes) / sizeof(mz_uint);
1273  
1274 /* Determine compression level by reversing the process in tdefl_create_comp_flags_from_zip_params() */
1275 0 ▶ for (i = 0; i < mz_un; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < mz_un; i++) 0 0 0
1276 0 ▶ if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF))
Branch: 1 branch
BranchTrueFalseTotal
if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) 0 0 0
1277 0 break;
1278  
1279 0 ▶ if (i < 2)
Branch: 1 branch
BranchTrueFalseTotal
if (i < 2) 0 0 0
1280 0 flevel = 0;
1281 0 ▶ else if (i < 6)
Branch: 1 branch
BranchTrueFalseTotal
else if (i < 6) 0 0 0
1282 0 flevel = 1;
1283 0 ▶ else if (i == 6)
Branch: 1 branch
BranchTrueFalseTotal
else if (i == 6) 0 0 0
1284 0 flevel = 2;
1285  
1286 0 header = cmf << 8 | (flevel << 6);
1287 0 header += 31 - (header % 31);
1288 0 flg = header & 0xFF;
1289  
1290 0 ▶ TDEFL_PUT_BITS(cmf, 8);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(cmf, 8); 0 0 0
TDEFL_PUT_BITS(cmf, 8); 0 0 0
1291 0 ▶ TDEFL_PUT_BITS(flg, 8);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(flg, 8); 0 0 0
TDEFL_PUT_BITS(flg, 8); 0 0 0
1292 }
1293  
1294 0 ▶ TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); 0 0 0
TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); 0 0 0
1295  
1296 0 pSaved_output_buf = d->m_pOutput_buf;
1297 0 saved_bit_buf = d->m_bit_buffer;
1298 0 saved_bits_in = d->m_bits_in;
1299  
1300 0 ▶ if (!use_raw_block)
Branch: 1 branch
BranchTrueFalseTotal
if (!use_raw_block) 0 0 0
1301 0 ▶ comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48));
Branch: 2 branches
BranchTrueFalseTotal
comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48)); 0 0 0
comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48)); 0 0 0
1302  
1303 /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */
1304 0 ▶ if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) &&
Branch: 3 branches
BranchTrueFalseTotal
if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && 0 0 0
if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && 0 0 0
if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && 0 0 0
1305 0 ▶ ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size))
Branch: 1 branch
BranchTrueFalseTotal
((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) 0 0 0
1306 0 {
1307 mz_uint i;
1308 0 d->m_pOutput_buf = pSaved_output_buf;
1309 0 d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
1310 0 ▶ TDEFL_PUT_BITS(0, 2);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(0, 2); 0 0 0
TDEFL_PUT_BITS(0, 2); 0 0 0
1311 0 ▶ if (d->m_bits_in)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_bits_in) 0 0 0
1312 {
1313 0 ▶ TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
1314 }
1315 0 ▶ for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) 0 0 0
1316 {
1317 0 ▶ TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); 0 0 0
TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); 0 0 0
1318 }
1319 0 ▶ for (i = 0; i < d->m_total_lz_bytes; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < d->m_total_lz_bytes; ++i) 0 0 0
1320 {
1321 0 ▶ TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); 0 0 0
TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); 0 0 0
1322 }
1323 }
1324 /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */
1325 0 ▶ else if (!comp_block_succeeded)
Branch: 1 branch
BranchTrueFalseTotal
else if (!comp_block_succeeded) 0 0 0
1326 {
1327 0 d->m_pOutput_buf = pSaved_output_buf;
1328 0 d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in;
1329 0 tdefl_compress_block(d, MZ_TRUE);
1330 }
1331  
1332 0 ▶ if (flush)
Branch: 1 branch
BranchTrueFalseTotal
if (flush) 0 0 0
1333 {
1334 0 ▶ if (flush == TDEFL_FINISH)
Branch: 1 branch
BranchTrueFalseTotal
if (flush == TDEFL_FINISH) 0 0 0
1335 {
1336 0 ▶ if (d->m_bits_in)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_bits_in) 0 0 0
1337 {
1338 0 ▶ TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
1339 }
1340 0 ▶ if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) 0 0 0
1341 {
1342 0 mz_uint i, a = d->m_adler32;
1343 0 ▶ for (i = 0; i < 4; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 4; i++) 0 0 0
1344 {
1345 0 ▶ TDEFL_PUT_BITS((a >> 24) & 0xFF, 8);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); 0 0 0
TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); 0 0 0
1346 0 a <<= 8;
1347 }
1348 }
1349 }
1350 else
1351 {
1352 0 mz_uint i, z = 0;
1353 0 ▶ TDEFL_PUT_BITS(0, 3);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(0, 3); 0 0 0
TDEFL_PUT_BITS(0, 3); 0 0 0
1354 0 ▶ if (d->m_bits_in)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_bits_in) 0 0 0
1355 {
1356 0 ▶ TDEFL_PUT_BITS(0, 8 - d->m_bits_in);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
TDEFL_PUT_BITS(0, 8 - d->m_bits_in); 0 0 0
1357 }
1358 0 ▶ for (i = 2; i; --i, z ^= 0xFFFF)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 2; i; --i, z ^= 0xFFFF) 0 0 0
1359 {
1360 0 ▶ TDEFL_PUT_BITS(z & 0xFFFF, 16);
Branch: 2 branches
BranchTrueFalseTotal
TDEFL_PUT_BITS(z & 0xFFFF, 16); 0 0 0
TDEFL_PUT_BITS(z & 0xFFFF, 16); 0 0 0
1361 }
1362 }
1363 }
1364  
1365 MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end);
1366  
1367 0 memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
1368 0 memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
1369  
1370 0 d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
1371 0 d->m_pLZ_flags = d->m_lz_code_buf;
1372 0 d->m_num_flags_left = 8;
1373 0 d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes;
1374 0 d->m_total_lz_bytes = 0;
1375 0 d->m_block_index++;
1376  
1377 0 ▶ if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) 0 0 0
1378 {
1379 0 ▶ if (d->m_pPut_buf_func)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_pPut_buf_func) 0 0 0
1380 {
1381 0 *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
1382 0 ▶ if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user))
Branch: 1 branch
BranchTrueFalseTotal
if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) 0 0 0
1383 0 return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED);
1384 }
1385 0 ▶ else if (pOutput_buf_start == d->m_output_buf)
Branch: 1 branch
BranchTrueFalseTotal
else if (pOutput_buf_start == d->m_output_buf) 0 0 0
1386 {
1387 0 ▶ int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs));
Branch: 1 branch
BranchTrueFalseTotal
int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); 0 0 0
1388 0 memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy);
1389 0 d->m_out_buf_ofs += bytes_to_copy;
1390 0 ▶ if ((n -= bytes_to_copy) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((n -= bytes_to_copy) != 0) 0 0 0
1391 {
1392 0 d->m_output_flush_ofs = bytes_to_copy;
1393 0 d->m_output_flush_remaining = n;
1394 }
1395 }
1396 else
1397 {
1398 0 d->m_out_buf_ofs += n;
1399 }
1400 }
1401  
1402 0 return d->m_output_flush_remaining;
1403 }
1404  
1405 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
1406 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
1407 static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8 *p)
1408 {
1409 mz_uint16 ret;
1410 memcpy(&ret, p, sizeof(mz_uint16));
1411 return ret;
1412 }
1413 static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16 *p)
1414 {
1415 mz_uint16 ret;
1416 memcpy(&ret, p, sizeof(mz_uint16));
1417 return ret;
1418 }
1419 #else
1420 #define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p)
1421 #define TDEFL_READ_UNALIGNED_WORD2(p) *(const mz_uint16 *)(p)
1422 #endif
1423 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
1424 {
1425 mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
1426 mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
1427 const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q;
1428 mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD2(s);
1429 MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
1430 if (max_match_len <= match_len)
1431 return;
1432 for (;;)
1433 {
1434 for (;;)
1435 {
1436 if (--num_probes_left == 0)
1437 return;
1438 #define TDEFL_PROBE \
1439 next_probe_pos = d->m_next[probe_pos]; \
1440 if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \
1441 return; \
1442 probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
1443 if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) \
1444 break;
1445 TDEFL_PROBE;
1446 TDEFL_PROBE;
1447 TDEFL_PROBE;
1448 }
1449 if (!dist)
1450 break;
1451 q = (const mz_uint16 *)(d->m_dict + probe_pos);
1452 if (TDEFL_READ_UNALIGNED_WORD2(q) != s01)
1453 continue;
1454 p = s;
1455 probe_len = 32;
1456 do
1457 {
1458 } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
1459 (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
1460 if (!probe_len)
1461 {
1462 *pMatch_dist = dist;
1463 *pMatch_len = MZ_MIN(max_match_len, (mz_uint)TDEFL_MAX_MATCH_LEN);
1464 break;
1465 }
1466 else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q)) > match_len)
1467 {
1468 *pMatch_dist = dist;
1469 if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len)
1470 break;
1471 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]);
1472 }
1473 }
1474 }
1475 #else
1476 static MZ_FORCEINLINE void tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, mz_uint max_match_len, mz_uint *pMatch_dist, mz_uint *pMatch_len)
1477 {
1478 0 mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len;
1479 0 mz_uint num_probes_left = d->m_max_probes[match_len >= 32];
1480 0 const mz_uint8 *s = d->m_dict + pos, *p, *q;
1481 0 mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1];
1482 MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN);
1483 0 if (max_match_len <= match_len)
1484 0 return;
1485 0 for (;;)
1486 {
1487 for (;;)
1488 {
1489 0 ▶ if (--num_probes_left == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (--num_probes_left == 0) 0 0 0
1490 0 return;
1491 #define TDEFL_PROBE \
1492 next_probe_pos = d->m_next[probe_pos]; \
1493 if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \
1494 return; \
1495 probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \
1496 if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \
1497 break;
1498 0 ▶ TDEFL_PROBE;
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
1499 0 ▶ TDEFL_PROBE;
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
1500 0 ▶ TDEFL_PROBE;
Branch: 4 branches
BranchTrueFalseTotal
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
TDEFL_PROBE; 0 0 0
1501 }
1502 0 ▶ if (!dist)
Branch: 1 branch
BranchTrueFalseTotal
if (!dist) 0 0 0
1503 0 break;
1504 0 p = s;
1505 0 q = d->m_dict + probe_pos;
1506 0 ▶ for (probe_len = 0; probe_len < max_match_len; probe_len++)
Branch: 1 branch
BranchTrueFalseTotal
for (probe_len = 0; probe_len < max_match_len; probe_len++) 0 0 0
1507 0 ▶ if (*p++ != *q++)
Branch: 1 branch
BranchTrueFalseTotal
if (*p++ != *q++) 0 0 0
1508 0 break;
1509 0 ▶ if (probe_len > match_len)
Branch: 1 branch
BranchTrueFalseTotal
if (probe_len > match_len) 0 0 0
1510 {
1511 0 *pMatch_dist = dist;
1512 0 ▶ if ((*pMatch_len = match_len = probe_len) == max_match_len)
Branch: 1 branch
BranchTrueFalseTotal
if ((*pMatch_len = match_len = probe_len) == max_match_len) 0 0 0
1513 0 return;
1514 0 c0 = d->m_dict[pos + match_len];
1515 0 c1 = d->m_dict[pos + match_len - 1];
1516 }
1517 }
1518 }
1519 #endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES */
1520  
1521 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
1522 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
1523 static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8 *p)
1524 {
1525 mz_uint32 ret;
1526 memcpy(&ret, p, sizeof(mz_uint32));
1527 return ret;
1528 }
1529 #else
1530 #define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p)
1531 #endif
1532 static mz_bool tdefl_compress_fast(tdefl_compressor *d)
1533 {
1534 /* Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio. */
1535 mz_uint lookahead_pos = d->m_lookahead_pos, lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, total_lz_bytes = d->m_total_lz_bytes, num_flags_left = d->m_num_flags_left;
1536 mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags;
1537 mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
1538  
1539 while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size)))
1540 {
1541 const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096;
1542 mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
1543 mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size);
1544 d->m_src_buf_left -= num_bytes_to_process;
1545 lookahead_size += num_bytes_to_process;
1546  
1547 while (num_bytes_to_process)
1548 {
1549 mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process);
1550 memcpy(d->m_dict + dst_pos, d->m_pSrc, n);
1551 if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
1552 memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos));
1553 d->m_pSrc += n;
1554 dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK;
1555 num_bytes_to_process -= n;
1556 }
1557  
1558 dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size);
1559 if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE))
1560 break;
1561  
1562 while (lookahead_size >= 4)
1563 {
1564 mz_uint cur_match_dist, cur_match_len = 1;
1565 mz_uint8 *pCur_dict = d->m_dict + cur_pos;
1566 mz_uint first_trigram = TDEFL_READ_UNALIGNED_WORD32(pCur_dict) & 0xFFFFFF;
1567 mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK;
1568 mz_uint probe_pos = d->m_hash[hash];
1569 d->m_hash[hash] = (mz_uint16)lookahead_pos;
1570  
1571 if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= dict_size) && ((TDEFL_READ_UNALIGNED_WORD32(d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & 0xFFFFFF) == first_trigram))
1572 {
1573 const mz_uint16 *p = (const mz_uint16 *)pCur_dict;
1574 const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos);
1575 mz_uint32 probe_len = 32;
1576 do
1577 {
1578 } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) &&
1579 (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0));
1580 cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q);
1581 if (!probe_len)
1582 cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0;
1583  
1584 if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)))
1585 {
1586 cur_match_len = 1;
1587 *pLZ_code_buf++ = (mz_uint8)first_trigram;
1588 *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
1589 d->m_huff_count[0][(mz_uint8)first_trigram]++;
1590 }
1591 else
1592 {
1593 mz_uint32 s0, s1;
1594 cur_match_len = MZ_MIN(cur_match_len, lookahead_size);
1595  
1596 MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE));
1597  
1598 cur_match_dist--;
1599  
1600 pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN);
1601 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
1602 memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist));
1603 #else
1604 *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist;
1605 #endif
1606 pLZ_code_buf += 3;
1607 *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80);
1608  
1609 s0 = s_tdefl_small_dist_sym[cur_match_dist & 511];
1610 s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8];
1611 d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++;
1612  
1613 d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++;
1614 }
1615 }
1616 else
1617 {
1618 *pLZ_code_buf++ = (mz_uint8)first_trigram;
1619 *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
1620 d->m_huff_count[0][(mz_uint8)first_trigram]++;
1621 }
1622  
1623 if (--num_flags_left == 0)
1624 {
1625 num_flags_left = 8;
1626 pLZ_flags = pLZ_code_buf++;
1627 }
1628  
1629 total_lz_bytes += cur_match_len;
1630 lookahead_pos += cur_match_len;
1631 dict_size = MZ_MIN(dict_size + cur_match_len, (mz_uint)TDEFL_LZ_DICT_SIZE);
1632 cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK;
1633 MZ_ASSERT(lookahead_size >= cur_match_len);
1634 lookahead_size -= cur_match_len;
1635  
1636 if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
1637 {
1638 int n;
1639 d->m_lookahead_pos = lookahead_pos;
1640 d->m_lookahead_size = lookahead_size;
1641 d->m_dict_size = dict_size;
1642 d->m_total_lz_bytes = total_lz_bytes;
1643 d->m_pLZ_code_buf = pLZ_code_buf;
1644 d->m_pLZ_flags = pLZ_flags;
1645 d->m_num_flags_left = num_flags_left;
1646 if ((n = tdefl_flush_block(d, 0)) != 0)
1647 return (n < 0) ? MZ_FALSE : MZ_TRUE;
1648 total_lz_bytes = d->m_total_lz_bytes;
1649 pLZ_code_buf = d->m_pLZ_code_buf;
1650 pLZ_flags = d->m_pLZ_flags;
1651 num_flags_left = d->m_num_flags_left;
1652 }
1653 }
1654  
1655 while (lookahead_size)
1656 {
1657 mz_uint8 lit = d->m_dict[cur_pos];
1658  
1659 total_lz_bytes++;
1660 *pLZ_code_buf++ = lit;
1661 *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1);
1662 if (--num_flags_left == 0)
1663 {
1664 num_flags_left = 8;
1665 pLZ_flags = pLZ_code_buf++;
1666 }
1667  
1668 d->m_huff_count[0][lit]++;
1669  
1670 lookahead_pos++;
1671 dict_size = MZ_MIN(dict_size + 1, (mz_uint)TDEFL_LZ_DICT_SIZE);
1672 cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
1673 lookahead_size--;
1674  
1675 if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8])
1676 {
1677 int n;
1678 d->m_lookahead_pos = lookahead_pos;
1679 d->m_lookahead_size = lookahead_size;
1680 d->m_dict_size = dict_size;
1681 d->m_total_lz_bytes = total_lz_bytes;
1682 d->m_pLZ_code_buf = pLZ_code_buf;
1683 d->m_pLZ_flags = pLZ_flags;
1684 d->m_num_flags_left = num_flags_left;
1685 if ((n = tdefl_flush_block(d, 0)) != 0)
1686 return (n < 0) ? MZ_FALSE : MZ_TRUE;
1687 total_lz_bytes = d->m_total_lz_bytes;
1688 pLZ_code_buf = d->m_pLZ_code_buf;
1689 pLZ_flags = d->m_pLZ_flags;
1690 num_flags_left = d->m_num_flags_left;
1691 }
1692 }
1693 }
1694  
1695 d->m_lookahead_pos = lookahead_pos;
1696 d->m_lookahead_size = lookahead_size;
1697 d->m_dict_size = dict_size;
1698 d->m_total_lz_bytes = total_lz_bytes;
1699 d->m_pLZ_code_buf = pLZ_code_buf;
1700 d->m_pLZ_flags = pLZ_flags;
1701 d->m_num_flags_left = num_flags_left;
1702 return MZ_TRUE;
1703 }
1704 #endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
1705  
1706 static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit)
1707 {
1708 0 d->m_total_lz_bytes++;
1709 0 *d->m_pLZ_code_buf++ = lit;
1710 0 *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1);
1711 0 if (--d->m_num_flags_left == 0)
1712 {
1713 0 d->m_num_flags_left = 8;
1714 0 d->m_pLZ_flags = d->m_pLZ_code_buf++;
1715 }
1716 0 d->m_huff_count[0][lit]++;
1717 0 }
1718  
1719 static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist)
1720 {
1721 mz_uint32 s0, s1;
1722  
1723 MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE));
1724  
1725 0 d->m_total_lz_bytes += match_len;
1726  
1727 0 d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN);
1728  
1729 0 match_dist -= 1;
1730 0 d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF);
1731 0 d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8);
1732 0 d->m_pLZ_code_buf += 3;
1733  
1734 0 *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80);
1735 0 if (--d->m_num_flags_left == 0)
1736 {
1737 0 d->m_num_flags_left = 8;
1738 0 d->m_pLZ_flags = d->m_pLZ_code_buf++;
1739 }
1740  
1741 0 s0 = s_tdefl_small_dist_sym[match_dist & 511];
1742 0 s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127];
1743 0 ▶ d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++;
Branch: 3 branches
BranchTrueFalseTotal
d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; 0 0 0
d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; 0 0 0
d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; 0 0 0
1744 0 d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++;
1745 0 }
1746  
1747 0 static mz_bool tdefl_compress_normal(tdefl_compressor *d)
1748 {
1749 0 const mz_uint8 *pSrc = d->m_pSrc;
1750 0 size_t src_buf_left = d->m_src_buf_left;
1751 0 tdefl_flush flush = d->m_flush;
1752  
1753 0 ▶ while ((src_buf_left) || ((flush) && (d->m_lookahead_size)))
Branch: 3 branches
BranchTrueFalseTotal
while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) 0 0 0
while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) 0 0 0
while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) 0 0 0
1754 {
1755 mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos;
1756 /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */
1757 0 ▶ if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1))
Branch: 1 branch
BranchTrueFalseTotal
if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) 0 0 0
1758 {
1759 0 mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK, ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2;
1760 0 mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK];
1761 0 ▶ mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size);
Branch: 1 branch
BranchTrueFalseTotal
mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); 0 0 0
1762 0 ▶ const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL;
Branch: 1 branch
BranchTrueFalseTotal
const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; 0 0 0
1763 0 src_buf_left -= num_bytes_to_process;
1764 0 d->m_lookahead_size += num_bytes_to_process;
1765 0 ▶ while (pSrc != pSrc_end)
Branch: 1 branch
BranchTrueFalseTotal
while (pSrc != pSrc_end) 0 0 0
1766 {
1767 0 mz_uint8 c = *pSrc++;
1768 0 d->m_dict[dst_pos] = c;
1769 0 ▶ if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
Branch: 1 branch
BranchTrueFalseTotal
if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) 0 0 0
1770 0 d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
1771 0 hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
1772 0 d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
1773 0 d->m_hash[hash] = (mz_uint16)(ins_pos);
1774 0 dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK;
1775 0 ins_pos++;
1776 }
1777 }
1778 else
1779 {
1780 0 ▶ while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
Branch: 2 branches
BranchTrueFalseTotal
while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) 0 0 0
while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) 0 0 0
1781 {
1782 0 mz_uint8 c = *pSrc++;
1783 0 mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK;
1784 0 src_buf_left--;
1785 0 d->m_dict[dst_pos] = c;
1786 0 ▶ if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1))
Branch: 1 branch
BranchTrueFalseTotal
if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) 0 0 0
1787 0 d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c;
1788 0 ▶ if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN)
Branch: 1 branch
BranchTrueFalseTotal
if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) 0 0 0
1789 {
1790 0 mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2;
1791 0 mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] << (TDEFL_LZ_HASH_SHIFT * 2)) ^ (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1);
1792 0 d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash];
1793 0 d->m_hash[hash] = (mz_uint16)(ins_pos);
1794 }
1795 }
1796 }
1797 0 d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size);
1798 0 ▶ if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN))
Branch: 2 branches
BranchTrueFalseTotal
if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) 0 0 0
if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) 0 0 0
1799 0 break;
1800  
1801 /* Simple lazy/greedy parsing state machine. */
1802 0 len_to_move = 1;
1803 0 cur_match_dist = 0;
1804 0 ▶ cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1);
Branch: 1 branch
BranchTrueFalseTotal
cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); 0 0 0
1805 0 cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK;
1806 0 ▶ if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS))
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) 0 0 0
1807 {
1808 0 ▶ if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))
Branch: 2 branches
BranchTrueFalseTotal
if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) 0 0 0
if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) 0 0 0
1809 {
1810 0 mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK];
1811 0 cur_match_len = 0;
1812 0 ▶ while (cur_match_len < d->m_lookahead_size)
Branch: 1 branch
BranchTrueFalseTotal
while (cur_match_len < d->m_lookahead_size) 0 0 0
1813 {
1814 0 ▶ if (d->m_dict[cur_pos + cur_match_len] != c)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_dict[cur_pos + cur_match_len] != c) 0 0 0
1815 0 break;
1816 0 cur_match_len++;
1817 }
1818 0 ▶ if (cur_match_len < TDEFL_MIN_MATCH_LEN)
Branch: 1 branch
BranchTrueFalseTotal
if (cur_match_len < TDEFL_MIN_MATCH_LEN) 0 0 0
1819 0 cur_match_len = 0;
1820 else
1821 0 cur_match_dist = 1;
1822 }
1823 }
1824 else
1825 {
1826 0 ▶ tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len); 0 0 0
1827 }
1828 0 ▶ if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5)))
Branch: 5 branches
BranchTrueFalseTotal
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) 0 0 0
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) 0 0 0
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) 0 0 0
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) 0 0 0
if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U)) || (cur_pos == cur_match_dist) || ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) 0 0 0
1829 {
1830 0 cur_match_dist = cur_match_len = 0;
1831 }
1832 0 ▶ if (d->m_saved_match_len)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_saved_match_len) 0 0 0
1833 {
1834 0 ▶ if (cur_match_len > d->m_saved_match_len)
Branch: 1 branch
BranchTrueFalseTotal
if (cur_match_len > d->m_saved_match_len) 0 0 0
1835 {
1836 0 ▶ tdefl_record_literal(d, (mz_uint8)d->m_saved_lit);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); 0 0 0
1837 0 ▶ if (cur_match_len >= 128)
Branch: 1 branch
BranchTrueFalseTotal
if (cur_match_len >= 128) 0 0 0
1838 {
1839 0 ▶ tdefl_record_match(d, cur_match_len, cur_match_dist);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_record_match(d, cur_match_len, cur_match_dist); 0 0 0
1840 0 d->m_saved_match_len = 0;
1841 0 len_to_move = cur_match_len;
1842 }
1843 else
1844 {
1845 0 d->m_saved_lit = d->m_dict[cur_pos];
1846 0 d->m_saved_match_dist = cur_match_dist;
1847 0 d->m_saved_match_len = cur_match_len;
1848 }
1849 }
1850 else
1851 {
1852 0 ▶ tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); 0 0 0
1853 0 len_to_move = d->m_saved_match_len - 1;
1854 0 d->m_saved_match_len = 0;
1855 }
1856 }
1857 0 ▶ else if (!cur_match_dist)
Branch: 1 branch
BranchTrueFalseTotal
else if (!cur_match_dist) 0 0 0
1858 0 ▶ tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); 0 0 0
1859 0 ▶ else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128))
Branch: 3 branches
BranchTrueFalseTotal
else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) 0 0 0
else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) 0 0 0
else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) 0 0 0
1860 {
1861 0 ▶ tdefl_record_match(d, cur_match_len, cur_match_dist);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_record_match(d, cur_match_len, cur_match_dist); 0 0 0
1862 0 len_to_move = cur_match_len;
1863 }
1864 else
1865 {
1866 0 d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)];
1867 0 d->m_saved_match_dist = cur_match_dist;
1868 0 d->m_saved_match_len = cur_match_len;
1869 }
1870 /* Move the lookahead forward by len_to_move bytes. */
1871 0 d->m_lookahead_pos += len_to_move;
1872 MZ_ASSERT(d->m_lookahead_size >= len_to_move);
1873 0 d->m_lookahead_size -= len_to_move;
1874 0 d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE);
1875 /* Check if it's time to flush the current LZ codes to the internal output buffer. */
1876 0 ▶ if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) ||
Branch: 1 branch
BranchTrueFalseTotal
if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || 0 0 0
1877 0 ▶ ((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))))
Branch: 3 branches
BranchTrueFalseTotal
((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) 0 0 0
((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) 0 0 0
((d->m_total_lz_bytes > 31 * 1024) && (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= d->m_total_lz_bytes) || (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) 0 0 0
1878 {
1879 int n;
1880 0 d->m_pSrc = pSrc;
1881 0 d->m_src_buf_left = src_buf_left;
1882 0 ▶ if ((n = tdefl_flush_block(d, 0)) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((n = tdefl_flush_block(d, 0)) != 0) 0 0 0
1883 0 return (n < 0) ? MZ_FALSE : MZ_TRUE;
1884 }
1885 }
1886  
1887 0 d->m_pSrc = pSrc;
1888 0 d->m_src_buf_left = src_buf_left;
1889 0 return MZ_TRUE;
1890 }
1891  
1892 0 static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
1893 {
1894 0 ▶ if (d->m_pIn_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_pIn_buf_size) 0 0 0
1895 {
1896 0 *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
1897 }
1898  
1899 0 ▶ if (d->m_pOut_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (d->m_pOut_buf_size) 0 0 0
1900 {
1901 0 size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
1902 0 memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
1903 0 d->m_output_flush_ofs += (mz_uint)n;
1904 0 d->m_output_flush_remaining -= (mz_uint)n;
1905 0 d->m_out_buf_ofs += n;
1906  
1907 0 *d->m_pOut_buf_size = d->m_out_buf_ofs;
1908 }
1909  
1910 0 ▶ return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
Branch: 2 branches
BranchTrueFalseTotal
return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; 0 0 0
return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; 0 0 0
1911 }
1912  
1913 0 tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush)
1914 {
1915 0 ▶ if (!d)
Branch: 1 branch
BranchTrueFalseTotal
if (!d) 0 0 0
1916 {
1917 0 ▶ if (pIn_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pIn_buf_size) 0 0 0
1918 0 *pIn_buf_size = 0;
1919 0 ▶ if (pOut_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pOut_buf_size) 0 0 0
1920 0 *pOut_buf_size = 0;
1921 0 return TDEFL_STATUS_BAD_PARAM;
1922 }
1923  
1924 0 d->m_pIn_buf = pIn_buf;
1925 0 d->m_pIn_buf_size = pIn_buf_size;
1926 0 d->m_pOut_buf = pOut_buf;
1927 0 d->m_pOut_buf_size = pOut_buf_size;
1928 0 d->m_pSrc = (const mz_uint8 *)(pIn_buf);
1929 0 ▶ d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
Branch: 1 branch
BranchTrueFalseTotal
d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; 0 0 0
1930 0 d->m_out_buf_ofs = 0;
1931 0 d->m_flush = flush;
1932  
1933 0 ▶ if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
Branch: 4 branches
BranchTrueFalseTotal
if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || 0 0 0
if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || 0 0 0
if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || 0 0 0
if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || 0 0 0
1934 0 ▶ (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
Branch: 8 branches
BranchTrueFalseTotal
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
(d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) 0 0 0
1935 {
1936 0 ▶ if (pIn_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pIn_buf_size) 0 0 0
1937 0 *pIn_buf_size = 0;
1938 0 ▶ if (pOut_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pOut_buf_size) 0 0 0
1939 0 *pOut_buf_size = 0;
1940 0 return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM);
1941 }
1942 0 d->m_wants_to_finish |= (flush == TDEFL_FINISH);
1943  
1944 0 ▶ if ((d->m_output_flush_remaining) || (d->m_finished))
Branch: 2 branches
BranchTrueFalseTotal
if ((d->m_output_flush_remaining) || (d->m_finished)) 0 0 0
if ((d->m_output_flush_remaining) || (d->m_finished)) 0 0 0
1945 0 return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
1946  
1947 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
1948 if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
1949 ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
1950 ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0))
1951 {
1952 if (!tdefl_compress_fast(d))
1953 return d->m_prev_return_status;
1954 }
1955 else
1956 #endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
1957 {
1958 0 ▶ if (!tdefl_compress_normal(d))
Branch: 1 branch
BranchTrueFalseTotal
if (!tdefl_compress_normal(d)) 0 0 0
1959 0 return d->m_prev_return_status;
1960 }
1961  
1962 0 ▶ if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
Branch: 2 branches
BranchTrueFalseTotal
if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) 0 0 0
if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) 0 0 0
1963 0 d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
1964  
1965 0 ▶ if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
Branch: 4 branches
BranchTrueFalseTotal
if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) 0 0 0
if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) 0 0 0
if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) 0 0 0
if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) 0 0 0
1966 {
1967 0 ▶ if (tdefl_flush_block(d, flush) < 0)
Branch: 1 branch
BranchTrueFalseTotal
if (tdefl_flush_block(d, flush) < 0) 0 0 0
1968 0 return d->m_prev_return_status;
1969 0 d->m_finished = (flush == TDEFL_FINISH);
1970 0 ▶ if (flush == TDEFL_FULL_FLUSH)
Branch: 1 branch
BranchTrueFalseTotal
if (flush == TDEFL_FULL_FLUSH) 0 0 0
1971 {
1972 0 MZ_CLEAR_ARR(d->m_hash);
1973 0 MZ_CLEAR_ARR(d->m_next);
1974 0 d->m_dict_size = 0;
1975 }
1976 }
1977  
1978 0 return (d->m_prev_return_status = tdefl_flush_output_buffer(d));
1979 }
1980  
1981 0 tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
1982 {
1983 MZ_ASSERT(d->m_pPut_buf_func);
1984 0 return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
1985 }
1986  
1987 0 tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
1988 {
1989 0 d->m_pPut_buf_func = pPut_buf_func;
1990 0 d->m_pPut_buf_user = pPut_buf_user;
1991 0 d->m_flags = (mz_uint)(flags);
1992 0 d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3;
1993 0 d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
1994 0 d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
1995 0 ▶ if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
Branch: 1 branch
BranchTrueFalseTotal
if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) 0 0 0
1996 0 MZ_CLEAR_ARR(d->m_hash);
1997 0 d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0;
1998 0 d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0;
1999 0 d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
2000 0 d->m_pLZ_flags = d->m_lz_code_buf;
2001 0 *d->m_pLZ_flags = 0;
2002 0 d->m_num_flags_left = 8;
2003 0 d->m_pOutput_buf = d->m_output_buf;
2004 0 d->m_pOutput_buf_end = d->m_output_buf;
2005 0 d->m_prev_return_status = TDEFL_STATUS_OKAY;
2006 0 d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0;
2007 0 d->m_adler32 = 1;
2008 0 d->m_pIn_buf = NULL;
2009 0 d->m_pOut_buf = NULL;
2010 0 d->m_pIn_buf_size = NULL;
2011 0 d->m_pOut_buf_size = NULL;
2012 0 d->m_flush = TDEFL_NO_FLUSH;
2013 0 d->m_pSrc = NULL;
2014 0 d->m_src_buf_left = 0;
2015 0 d->m_out_buf_ofs = 0;
2016 0 ▶ if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG))
Branch: 1 branch
BranchTrueFalseTotal
if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) 0 0 0
2017 0 MZ_CLEAR_ARR(d->m_dict);
2018 0 memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
2019 0 memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
2020 0 return TDEFL_STATUS_OKAY;
2021 }
2022  
2023 0 tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d)
2024 {
2025 0 return d->m_prev_return_status;
2026 }
2027  
2028 0 mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
2029 {
2030 0 return d->m_adler32;
2031 }
2032  
2033 0 mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
2034 {
2035 tdefl_compressor *pComp;
2036 mz_bool succeeded;
2037 0 ▶ if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
Branch: 3 branches
BranchTrueFalseTotal
if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) 0 0 0
if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) 0 0 0
if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) 0 0 0
2038 0 return MZ_FALSE;
2039 0 pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
2040 0 ▶ if (!pComp)
Branch: 1 branch
BranchTrueFalseTotal
if (!pComp) 0 0 0
2041 0 return MZ_FALSE;
2042 0 succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
2043 0 ▶ succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
Branch: 2 branches
BranchTrueFalseTotal
succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE); 0 0 0
succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE); 0 0 0
2044 0 MZ_FREE(pComp);
2045 0 return succeeded;
2046 }
2047  
2048 typedef struct
2049 {
2050 size_t m_size, m_capacity;
2051 mz_uint8 *m_pBuf;
2052 mz_bool m_expandable;
2053 } tdefl_output_buffer;
2054  
2055 0 static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
2056 {
2057 0 tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
2058 0 size_t new_size = p->m_size + len;
2059 0 ▶ if (new_size > p->m_capacity)
Branch: 1 branch
BranchTrueFalseTotal
if (new_size > p->m_capacity) 0 0 0
2060 {
2061 0 size_t new_capacity = p->m_capacity;
2062 mz_uint8 *pNew_buf;
2063 0 ▶ if (!p->m_expandable)
Branch: 1 branch
BranchTrueFalseTotal
if (!p->m_expandable) 0 0 0
2064 0 return MZ_FALSE;
2065 do
2066 {
2067 0 new_capacity = MZ_MAX(128U, new_capacity << 1U);
2068 0 ▶ } while (new_size > new_capacity);
Branch: 1 branch
BranchTrueFalseTotal
} while (new_size > new_capacity); 0 0 0
2069 0 pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity);
2070 0 ▶ if (!pNew_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (!pNew_buf) 0 0 0
2071 0 return MZ_FALSE;
2072 0 p->m_pBuf = pNew_buf;
2073 0 p->m_capacity = new_capacity;
2074 }
2075 0 memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len);
2076 0 p->m_size = new_size;
2077 0 return MZ_TRUE;
2078 }
2079  
2080 0 void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
2081 {
2082 tdefl_output_buffer out_buf;
2083 0 MZ_CLEAR_OBJ(out_buf);
2084 0 ▶ if (!pOut_len)
Branch: 1 branch
BranchTrueFalseTotal
if (!pOut_len) 0 0 0
2085 0 return MZ_FALSE;
2086 else
2087 0 *pOut_len = 0;
2088 0 out_buf.m_expandable = MZ_TRUE;
2089 0 ▶ if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) 0 0 0
2090 0 return NULL;
2091 0 *pOut_len = out_buf.m_size;
2092 0 return out_buf.m_pBuf;
2093 }
2094  
2095 0 size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
2096 {
2097 tdefl_output_buffer out_buf;
2098 0 MZ_CLEAR_OBJ(out_buf);
2099 0 ▶ if (!pOut_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (!pOut_buf) 0 0 0
2100 0 return 0;
2101 0 out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
2102 0 out_buf.m_capacity = out_buf_len;
2103 0 ▶ if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) 0 0 0
2104 0 return 0;
2105 0 return out_buf.m_size;
2106 }
2107  
2108 /* level may actually range from [0,10] (10 is a "hidden" max level, where we want a bit more compression and it's fine if throughput to fall off a cliff on some files). */
2109 0 mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
2110 {
2111 0 ▶ mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
Branch: 2 branches
BranchTrueFalseTotal
mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); 0 0 0
mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); 0 0 0
2112 0 ▶ if (window_bits > 0)
Branch: 1 branch
BranchTrueFalseTotal
if (window_bits > 0) 0 0 0
2113 0 comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
2114  
2115 0 ▶ if (!level)
Branch: 1 branch
BranchTrueFalseTotal
if (!level) 0 0 0
2116 0 comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
2117 0 ▶ else if (strategy == MZ_FILTERED)
Branch: 1 branch
BranchTrueFalseTotal
else if (strategy == MZ_FILTERED) 0 0 0
2118 0 comp_flags |= TDEFL_FILTER_MATCHES;
2119 0 ▶ else if (strategy == MZ_HUFFMAN_ONLY)
Branch: 1 branch
BranchTrueFalseTotal
else if (strategy == MZ_HUFFMAN_ONLY) 0 0 0
2120 0 comp_flags &= ~TDEFL_MAX_PROBES_MASK;
2121 0 ▶ else if (strategy == MZ_FIXED)
Branch: 1 branch
BranchTrueFalseTotal
else if (strategy == MZ_FIXED) 0 0 0
2122 0 comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
2123 0 ▶ else if (strategy == MZ_RLE)
Branch: 1 branch
BranchTrueFalseTotal
else if (strategy == MZ_RLE) 0 0 0
2124 0 comp_flags |= TDEFL_RLE_MATCHES;
2125  
2126 0 return comp_flags;
2127 }
2128  
2129 #ifdef _MSC_VER
2130 #pragma warning(push)
2131 #pragma warning(disable : 4204) /* nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal) */
2132 #endif
2133  
2134 /* Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at
2135 http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/.
2136 This is actually a modification of Alex's original code so PNG files generated by this function pass pngcheck. */
2137 0 void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip)
2138 {
2139 /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */
2140 static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
2141 0 tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
2142 tdefl_output_buffer out_buf;
2143 0 int i, bpl = w * num_chans, y, z;
2144 mz_uint32 c;
2145 0 *pLen_out = 0;
2146 0 ▶ if (!pComp)
Branch: 1 branch
BranchTrueFalseTotal
if (!pComp) 0 0 0
2147 0 return NULL;
2148 0 MZ_CLEAR_OBJ(out_buf);
2149 0 out_buf.m_expandable = MZ_TRUE;
2150 0 out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h);
2151 0 ▶ if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity))) 0 0 0
2152 {
2153 0 MZ_FREE(pComp);
2154 0 return NULL;
2155 }
2156 /* write dummy header */
2157 0 ▶ for (z = 41; z; --z)
Branch: 1 branch
BranchTrueFalseTotal
for (z = 41; z; --z) 0 0 0
2158 0 tdefl_output_buffer_putter(&z, 1, &out_buf);
2159 /* compress image data */
2160 0 tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
2161 0 ▶ for (y = 0; y < h; ++y)
Branch: 1 branch
BranchTrueFalseTotal
for (y = 0; y < h; ++y) 0 0 0
2162 {
2163 0 tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH);
2164 0 ▶ tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH);
Branch: 1 branch
BranchTrueFalseTotal
tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH); 0 0 0
2165 }
2166 0 ▶ if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE) 0 0 0
2167 {
2168 0 MZ_FREE(pComp);
2169 0 MZ_FREE(out_buf.m_pBuf);
2170 0 return NULL;
2171 }
2172 /* write real header */
2173 0 *pLen_out = out_buf.m_size - 41;
2174 {
2175 static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
2176 0 mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,
2177 0x0a, 0x1a, 0x0a, 0x00, 0x00,
2178 0x00, 0x0d, 0x49, 0x48, 0x44,
2179 0x52, 0x00, 0x00, 0x00, 0x00,
2180 0x00, 0x00, 0x00, 0x00, 0x08,
2181 0x00, 0x00, 0x00, 0x00, 0x00,
2182 0x00, 0x00, 0x00, 0x00, 0x00,
2183 0x00, 0x00, 0x49, 0x44, 0x41,
2184 0x54 };
2185 0 pnghdr[18] = (mz_uint8)(w >> 8);
2186 0 pnghdr[19] = (mz_uint8)w;
2187 0 pnghdr[22] = (mz_uint8)(h >> 8);
2188 0 pnghdr[23] = (mz_uint8)h;
2189 0 pnghdr[25] = chans[num_chans];
2190 0 pnghdr[33] = (mz_uint8)(*pLen_out >> 24);
2191 0 pnghdr[34] = (mz_uint8)(*pLen_out >> 16);
2192 0 pnghdr[35] = (mz_uint8)(*pLen_out >> 8);
2193 0 pnghdr[36] = (mz_uint8)*pLen_out;
2194 0 c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
2195 0 ▶ for (i = 0; i < 4; ++i, c <<= 8)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 4; ++i, c <<= 8) 0 0 0
2196 0 ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24);
2197 0 memcpy(out_buf.m_pBuf, pnghdr, 41);
2198 }
2199 /* write footer (IDAT CRC-32, followed by IEND chunk) */
2200 0 ▶ if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf))
Branch: 1 branch
BranchTrueFalseTotal
if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf)) 0 0 0
2201 {
2202 0 *pLen_out = 0;
2203 0 MZ_FREE(pComp);
2204 0 MZ_FREE(out_buf.m_pBuf);
2205 0 return NULL;
2206 }
2207 0 c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4);
2208 0 ▶ for (i = 0; i < 4; ++i, c <<= 8)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < 4; ++i, c <<= 8) 0 0 0
2209 0 (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24);
2210 /* compute final size of file, grab compressed data buffer and return */
2211 0 *pLen_out += 57;
2212 0 MZ_FREE(pComp);
2213 0 return out_buf.m_pBuf;
2214 }
2215 0 void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out)
2216 {
2217 /* Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's where #defined out) */
2218 0 return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
2219 }
2220  
2221 #ifndef MINIZ_NO_MALLOC
2222 /* Allocate the tdefl_compressor and tinfl_decompressor structures in C so that */
2223 /* non-C language bindings to tdefL_ and tinfl_ API don't need to worry about */
2224 /* structure size and allocation mechanism. */
2225 0 tdefl_compressor *tdefl_compressor_alloc(void)
2226 {
2227 0 return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
2228 }
2229  
2230 0 void tdefl_compressor_free(tdefl_compressor *pComp)
2231 {
2232 0 MZ_FREE(pComp);
2233 0 }
2234 #endif
2235  
2236 #ifdef _MSC_VER
2237 #pragma warning(pop)
2238 #endif
2239  
2240 #ifdef __cplusplus
2241 }
2242 #endif
2243  
2244 #endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
2245 /**************************************************************************
2246 *
2247 * Copyright 2013-2014 RAD Game Tools and Valve Software
2248 * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
2249 * All Rights Reserved.
2250 *
2251 * Permission is hereby granted, free of charge, to any person obtaining a copy
2252 * of this software and associated documentation files (the "Software"), to deal
2253 * in the Software without restriction, including without limitation the rights
2254 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
2255 * copies of the Software, and to permit persons to whom the Software is
2256 * furnished to do so, subject to the following conditions:
2257 *
2258 * The above copyright notice and this permission notice shall be included in
2259 * all copies or substantial portions of the Software.
2260 *
2261 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
2262 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
2263 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
2264 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
2265 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
2266 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
2267 * THE SOFTWARE.
2268 *
2269 **************************************************************************/
2270  
2271  
2272  
2273 #ifndef MINIZ_NO_INFLATE_APIS
2274  
2275 #ifdef __cplusplus
2276 extern "C"
2277 {
2278 #endif
2279  
2280 /* ------------------- Low-level Decompression (completely independent from all compression API's) */
2281  
2282 #define TINFL_MEMCPY(d, s, l) memcpy(d, s, l)
2283 #define TINFL_MEMSET(p, c, l) memset(p, c, l)
2284  
2285 #define TINFL_CR_BEGIN \
2286 switch (r->m_state) \
2287 { \
2288 case 0:
2289 #define TINFL_CR_RETURN(state_index, result) \
2290 do \
2291 { \
2292 status = result; \
2293 r->m_state = state_index; \
2294 goto common_exit; \
2295 case state_index:; \
2296 } \
2297 MZ_MACRO_END
2298 #define TINFL_CR_RETURN_FOREVER(state_index, result) \
2299 do \
2300 { \
2301 for (;;) \
2302 { \
2303 TINFL_CR_RETURN(state_index, result); \
2304 } \
2305 } \
2306 MZ_MACRO_END
2307 #define TINFL_CR_FINISH }
2308  
2309 #define TINFL_GET_BYTE(state_index, c) \
2310 do \
2311 { \
2312 while (pIn_buf_cur >= pIn_buf_end) \
2313 { \
2314 TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \
2315 } \
2316 c = *pIn_buf_cur++; \
2317 } \
2318 MZ_MACRO_END
2319  
2320 #define TINFL_NEED_BITS(state_index, n) \
2321 do \
2322 { \
2323 mz_uint c; \
2324 TINFL_GET_BYTE(state_index, c); \
2325 bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \
2326 num_bits += 8; \
2327 } while (num_bits < (mz_uint)(n))
2328 #define TINFL_SKIP_BITS(state_index, n) \
2329 do \
2330 { \
2331 if (num_bits < (mz_uint)(n)) \
2332 { \
2333 TINFL_NEED_BITS(state_index, n); \
2334 } \
2335 bit_buf >>= (n); \
2336 num_bits -= (n); \
2337 } \
2338 MZ_MACRO_END
2339 #define TINFL_GET_BITS(state_index, b, n) \
2340 do \
2341 { \
2342 if (num_bits < (mz_uint)(n)) \
2343 { \
2344 TINFL_NEED_BITS(state_index, n); \
2345 } \
2346 b = bit_buf & ((1 << (n)) - 1); \
2347 bit_buf >>= (n); \
2348 num_bits -= (n); \
2349 } \
2350 MZ_MACRO_END
2351  
2352 /* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2. */
2353 /* It reads just enough bytes from the input stream that are needed to decode the next Huffman code (and absolutely no more). It works by trying to fully decode a */
2354 /* Huffman code by using whatever bits are currently present in the bit buffer. If this fails, it reads another byte, and tries again until it succeeds or until the */
2355 /* bit buffer contains >=15 bits (deflate's max. Huffman code size). */
2356 #define TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree) \
2357 do \
2358 { \
2359 temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \
2360 if (temp >= 0) \
2361 { \
2362 code_len = temp >> 9; \
2363 if ((code_len) && (num_bits >= code_len)) \
2364 break; \
2365 } \
2366 else if (num_bits > TINFL_FAST_LOOKUP_BITS) \
2367 { \
2368 code_len = TINFL_FAST_LOOKUP_BITS; \
2369 do \
2370 { \
2371 temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \
2372 } while ((temp < 0) && (num_bits >= (code_len + 1))); \
2373 if (temp >= 0) \
2374 break; \
2375 } \
2376 TINFL_GET_BYTE(state_index, c); \
2377 bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \
2378 num_bits += 8; \
2379 } while (num_bits < 15);
2380  
2381 /* TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex than you would initially expect because the zlib API expects the decompressor to never read */
2382 /* beyond the final byte of the deflate stream. (In other words, when this macro wants to read another byte from the input, it REALLY needs another byte in order to fully */
2383 /* decode the next Huffman code.) Handling this properly is particularly important on raw deflate (non-zlib) streams, which aren't followed by a byte aligned adler-32. */
2384 /* The slow path is only executed at the very end of the input buffer. */
2385 /* v1.16: The original macro handled the case at the very end of the passed-in input buffer, but we also need to handle the case where the user passes in 1+zillion bytes */
2386 /* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */
2387 #define TINFL_HUFF_DECODE(state_index, sym, pLookUp, pTree) \
2388 do \
2389 { \
2390 int temp; \
2391 mz_uint code_len, c; \
2392 if (num_bits < 15) \
2393 { \
2394 if ((pIn_buf_end - pIn_buf_cur) < 2) \
2395 { \
2396 TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \
2397 } \
2398 else \
2399 { \
2400 bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \
2401 pIn_buf_cur += 2; \
2402 num_bits += 16; \
2403 } \
2404 } \
2405 if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \
2406 code_len = temp >> 9, temp &= 511; \
2407 else \
2408 { \
2409 code_len = TINFL_FAST_LOOKUP_BITS; \
2410 do \
2411 { \
2412 temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \
2413 } while (temp < 0); \
2414 } \
2415 sym = temp; \
2416 bit_buf >>= code_len; \
2417 num_bits -= code_len; \
2418 } \
2419 MZ_MACRO_END
2420  
2421 0 static void tinfl_clear_tree(tinfl_decompressor *r)
2422 {
2423 0 ▶ if (r->m_type == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (r->m_type == 0) 0 0 0
2424 0 MZ_CLEAR_ARR(r->m_tree_0);
2425 0 ▶ else if (r->m_type == 1)
Branch: 1 branch
BranchTrueFalseTotal
else if (r->m_type == 1) 0 0 0
2426 0 MZ_CLEAR_ARR(r->m_tree_1);
2427 else
2428 0 MZ_CLEAR_ARR(r->m_tree_2);
2429 0 }
2430  
2431 0 tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags)
2432 {
2433 static const mz_uint16 s_length_base[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };
2434 static const mz_uint8 s_length_extra[31] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0 };
2435 static const mz_uint16 s_dist_base[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0 };
2436 static const mz_uint8 s_dist_extra[32] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
2437 static const mz_uint8 s_length_dezigzag[19] = { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
2438 static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 };
2439  
2440 mz_int16 *pTrees[3];
2441 mz_uint8 *pCode_sizes[3];
2442  
2443 0 tinfl_status status = TINFL_STATUS_FAILED;
2444 mz_uint32 num_bits, dist, counter, num_extra;
2445 tinfl_bit_buf_t bit_buf;
2446 0 const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
2447 0 ▶ mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL;
Branch: 1 branch
BranchTrueFalseTotal
mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL; 0 0 0
2448 0 ▶ size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start;
Branch: 1 branch
BranchTrueFalseTotal
size_t out_buf_size_mask = (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) ? (size_t)-1 : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, dist_from_out_buf_start; 0 0 0
2449  
2450 /* Ensure the output buffer's size is a power of 2, unless the output buffer is large enough to hold the entire output file (in which case it doesn't matter). */
2451 0 ▶ if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
Branch: 2 branches
BranchTrueFalseTotal
if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) 0 0 0
if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) 0 0 0
2452 {
2453 0 *pIn_buf_size = *pOut_buf_size = 0;
2454 0 return TINFL_STATUS_BAD_PARAM;
2455 }
2456  
2457 0 pTrees[0] = r->m_tree_0;
2458 0 pTrees[1] = r->m_tree_1;
2459 0 pTrees[2] = r->m_tree_2;
2460 0 pCode_sizes[0] = r->m_code_size_0;
2461 0 pCode_sizes[1] = r->m_code_size_1;
2462 0 pCode_sizes[2] = r->m_code_size_2;
2463  
2464 0 num_bits = r->m_num_bits;
2465 0 bit_buf = r->m_bit_buf;
2466 0 dist = r->m_dist;
2467 0 counter = r->m_counter;
2468 0 num_extra = r->m_num_extra;
2469 0 dist_from_out_buf_start = r->m_dist_from_out_buf_start;
2470 0 TINFL_CR_BEGIN
2471  
2472 0 bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
2473 0 r->m_z_adler32 = r->m_check_adler32 = 1;
2474 0 ▶ if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
Branch: 1 branch
BranchTrueFalseTotal
if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) 0 0 0
2475 {
2476 0 ▶ TINFL_GET_BYTE(1, r->m_zhdr0);
Branch: 2 branches
BranchTrueFalseTotal
TINFL_GET_BYTE(1, r->m_zhdr0); 0 0 0
TINFL_GET_BYTE(1, r->m_zhdr0); 0 0 0
2477 0 ▶ TINFL_GET_BYTE(2, r->m_zhdr1);
Branch: 2 branches
BranchTrueFalseTotal
TINFL_GET_BYTE(2, r->m_zhdr1); 0 0 0
TINFL_GET_BYTE(2, r->m_zhdr1); 0 0 0
2478 0 ▶ counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
Branch: 3 branches
BranchTrueFalseTotal
counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); 0 0 0
counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); 0 0 0
counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); 0 0 0
2479 0 ▶ if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
Branch: 1 branch
BranchTrueFalseTotal
if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) 0 0 0
2480 0 ▶ counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4)))));
Branch: 2 branches
BranchTrueFalseTotal
counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); 0 0 0
counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); 0 0 0
2481 0 ▶ if (counter)
Branch: 1 branch
BranchTrueFalseTotal
if (counter) 0 0 0
2482 {
2483 0 TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED);
2484 }
2485 }
2486  
2487 do
2488 {
2489 0 ▶ TINFL_GET_BITS(3, r->m_final, 3);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(3, r->m_final, 3); 0 0 0
TINFL_GET_BITS(3, r->m_final, 3); 0 0 0
TINFL_GET_BITS(3, r->m_final, 3); 0 0 0
TINFL_GET_BITS(3, r->m_final, 3); 0 0 0
2490 0 r->m_type = r->m_final >> 1;
2491 0 ▶ if (r->m_type == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (r->m_type == 0) 0 0 0
2492 {
2493 0 ▶ TINFL_SKIP_BITS(5, num_bits & 7);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_SKIP_BITS(5, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(5, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(5, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(5, num_bits & 7); 0 0 0
2494 0 ▶ for (counter = 0; counter < 4; ++counter)
Branch: 1 branch
BranchTrueFalseTotal
for (counter = 0; counter < 4; ++counter) 0 0 0
2495 {
2496 0 ▶ if (num_bits)
Branch: 1 branch
BranchTrueFalseTotal
if (num_bits) 0 0 0
2497 0 ▶ TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(6, r->m_raw_header[counter], 8); 0 0 0
TINFL_GET_BITS(6, r->m_raw_header[counter], 8); 0 0 0
TINFL_GET_BITS(6, r->m_raw_header[counter], 8); 0 0 0
TINFL_GET_BITS(6, r->m_raw_header[counter], 8); 0 0 0
2498 else
2499 0 ▶ TINFL_GET_BYTE(7, r->m_raw_header[counter]);
Branch: 2 branches
BranchTrueFalseTotal
TINFL_GET_BYTE(7, r->m_raw_header[counter]); 0 0 0
TINFL_GET_BYTE(7, r->m_raw_header[counter]); 0 0 0
2500 }
2501 0 ▶ if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8))))
Branch: 1 branch
BranchTrueFalseTotal
if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != (mz_uint)(0xFFFF ^ (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) 0 0 0
2502 {
2503 0 TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED);
2504 }
2505 0 ▶ while ((counter) && (num_bits))
Branch: 2 branches
BranchTrueFalseTotal
while ((counter) && (num_bits)) 0 0 0
while ((counter) && (num_bits)) 0 0 0
2506 {
2507 0 ▶ TINFL_GET_BITS(51, dist, 8);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(51, dist, 8); 0 0 0
TINFL_GET_BITS(51, dist, 8); 0 0 0
TINFL_GET_BITS(51, dist, 8); 0 0 0
TINFL_GET_BITS(51, dist, 8); 0 0 0
2508 0 while (pOut_buf_cur >= pOut_buf_end)
2509 {
2510 0 ▶ TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT);
Branch: 1 branch
BranchTrueFalseTotal
TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); 0 0 0
2511 }
2512 0 *pOut_buf_cur++ = (mz_uint8)dist;
2513 0 counter--;
2514 }
2515 0 ▶ while (counter)
Branch: 1 branch
BranchTrueFalseTotal
while (counter) 0 0 0
2516 {
2517 size_t n;
2518 0 while (pOut_buf_cur >= pOut_buf_end)
2519 {
2520 0 ▶ TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT);
Branch: 1 branch
BranchTrueFalseTotal
TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); 0 0 0
2521 }
2522 0 while (pIn_buf_cur >= pIn_buf_end)
2523 {
2524 0 ▶ TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS);
Branch: 2 branches
BranchTrueFalseTotal
TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); 0 0 0
TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); 0 0 0
2525 }
2526 0 n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
2527 0 TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
2528 0 pIn_buf_cur += n;
2529 0 pOut_buf_cur += n;
2530 0 counter -= (mz_uint)n;
2531 }
2532 }
2533 0 ▶ else if (r->m_type == 3)
Branch: 1 branch
BranchTrueFalseTotal
else if (r->m_type == 3) 0 0 0
2534 {
2535 0 TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED);
2536 }
2537 else
2538 {
2539 0 ▶ if (r->m_type == 1)
Branch: 1 branch
BranchTrueFalseTotal
if (r->m_type == 1) 0 0 0
2540 {
2541 0 mz_uint8 *p = r->m_code_size_0;
2542 mz_uint i;
2543 0 r->m_table_sizes[0] = 288;
2544 0 r->m_table_sizes[1] = 32;
2545 0 TINFL_MEMSET(r->m_code_size_1, 5, 32);
2546 0 ▶ for (i = 0; i <= 143; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i <= 143; ++i) 0 0 0
2547 0 *p++ = 8;
2548 0 ▶ for (; i <= 255; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 255; ++i) 0 0 0
2549 0 *p++ = 9;
2550 0 ▶ for (; i <= 279; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 279; ++i) 0 0 0
2551 0 *p++ = 7;
2552 0 ▶ for (; i <= 287; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i <= 287; ++i) 0 0 0
2553 0 *p++ = 8;
2554 }
2555 else
2556 {
2557 0 ▶ for (counter = 0; counter < 3; counter++)
Branch: 1 branch
BranchTrueFalseTotal
for (counter = 0; counter < 3; counter++) 0 0 0
2558 {
2559 0 ▶ TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); 0 0 0
TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); 0 0 0
TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); 0 0 0
TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); 0 0 0
2560 0 r->m_table_sizes[counter] += s_min_table_sizes[counter];
2561 }
2562 0 MZ_CLEAR_ARR(r->m_code_size_2);
2563 0 ▶ for (counter = 0; counter < r->m_table_sizes[2]; counter++)
Branch: 1 branch
BranchTrueFalseTotal
for (counter = 0; counter < r->m_table_sizes[2]; counter++) 0 0 0
2564 {
2565 mz_uint s;
2566 0 ▶ TINFL_GET_BITS(14, s, 3);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(14, s, 3); 0 0 0
TINFL_GET_BITS(14, s, 3); 0 0 0
TINFL_GET_BITS(14, s, 3); 0 0 0
TINFL_GET_BITS(14, s, 3); 0 0 0
2567 0 r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s;
2568 }
2569 0 r->m_table_sizes[2] = 19;
2570 }
2571 0 ▶ for (; (int)r->m_type >= 0; r->m_type--)
Branch: 1 branch
BranchTrueFalseTotal
for (; (int)r->m_type >= 0; r->m_type--) 0 0 0
2572 {
2573 int tree_next, tree_cur;
2574 mz_int16 *pLookUp;
2575 mz_int16 *pTree;
2576 mz_uint8 *pCode_size;
2577 mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
2578 0 pLookUp = r->m_look_up[r->m_type];
2579 0 pTree = pTrees[r->m_type];
2580 0 pCode_size = pCode_sizes[r->m_type];
2581 0 MZ_CLEAR_ARR(total_syms);
2582 0 TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0]));
2583 0 tinfl_clear_tree(r);
2584 0 ▶ for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) 0 0 0
2585 0 total_syms[pCode_size[i]]++;
2586 0 used_syms = 0, total = 0;
2587 0 next_code[0] = next_code[1] = 0;
2588 0 ▶ for (i = 1; i <= 15; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 1; i <= 15; ++i) 0 0 0
2589 {
2590 0 used_syms += total_syms[i];
2591 0 next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
2592 }
2593 0 ▶ if ((65536 != total) && (used_syms > 1))
Branch: 2 branches
BranchTrueFalseTotal
if ((65536 != total) && (used_syms > 1)) 0 0 0
if ((65536 != total) && (used_syms > 1)) 0 0 0
2594 {
2595 0 TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED);
2596 }
2597 0 ▶ for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
Branch: 1 branch
BranchTrueFalseTotal
for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) 0 0 0
2598 {
2599 0 mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index];
2600 0 ▶ if (!code_size)
Branch: 1 branch
BranchTrueFalseTotal
if (!code_size) 0 0 0
2601 0 continue;
2602 0 cur_code = next_code[code_size]++;
2603 0 ▶ for (l = code_size; l > 0; l--, cur_code >>= 1)
Branch: 1 branch
BranchTrueFalseTotal
for (l = code_size; l > 0; l--, cur_code >>= 1) 0 0 0
2604 0 rev_code = (rev_code << 1) | (cur_code & 1);
2605 0 ▶ if (code_size <= TINFL_FAST_LOOKUP_BITS)
Branch: 1 branch
BranchTrueFalseTotal
if (code_size <= TINFL_FAST_LOOKUP_BITS) 0 0 0
2606 0 {
2607 0 mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
2608 0 ▶ while (rev_code < TINFL_FAST_LOOKUP_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
while (rev_code < TINFL_FAST_LOOKUP_SIZE) 0 0 0
2609 {
2610 0 pLookUp[rev_code] = k;
2611 0 rev_code += (1 << code_size);
2612 }
2613 0 continue;
2614 }
2615 0 ▶ if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
Branch: 1 branch
BranchTrueFalseTotal
if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) 0 0 0
2616 {
2617 0 pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
2618 0 tree_cur = tree_next;
2619 0 tree_next -= 2;
2620 }
2621 0 rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
2622 0 ▶ for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
Branch: 1 branch
BranchTrueFalseTotal
for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) 0 0 0
2623 {
2624 0 tree_cur -= ((rev_code >>= 1) & 1);
2625 0 ▶ if (!pTree[-tree_cur - 1])
Branch: 1 branch
BranchTrueFalseTotal
if (!pTree[-tree_cur - 1]) 0 0 0
2626 {
2627 0 pTree[-tree_cur - 1] = (mz_int16)tree_next;
2628 0 tree_cur = tree_next;
2629 0 tree_next -= 2;
2630 }
2631 else
2632 0 tree_cur = pTree[-tree_cur - 1];
2633 }
2634 0 tree_cur -= ((rev_code >>= 1) & 1);
2635 0 pTree[-tree_cur - 1] = (mz_int16)sym_index;
2636 }
2637 0 ▶ if (r->m_type == 2)
Branch: 1 branch
BranchTrueFalseTotal
if (r->m_type == 2) 0 0 0
2638 {
2639 0 ▶ for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
Branch: 1 branch
BranchTrueFalseTotal
for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) 0 0 0
2640 {
2641 mz_uint s;
2642 0 ▶ TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2);
Branch: 14 branches
BranchTrueFalseTotal
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); 0 0 0
2643 0 ▶ if (dist < 16)
Branch: 1 branch
BranchTrueFalseTotal
if (dist < 16) 0 0 0
2644 {
2645 0 r->m_len_codes[counter++] = (mz_uint8)dist;
2646 0 continue;
2647 }
2648 0 ▶ if ((dist == 16) && (!counter))
Branch: 2 branches
BranchTrueFalseTotal
if ((dist == 16) && (!counter)) 0 0 0
if ((dist == 16) && (!counter)) 0 0 0
2649 {
2650 0 TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED);
2651 }
2652 0 num_extra = "\02\03\07"[dist - 16];
2653 0 ▶ TINFL_GET_BITS(18, s, num_extra);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(18, s, num_extra); 0 0 0
TINFL_GET_BITS(18, s, num_extra); 0 0 0
TINFL_GET_BITS(18, s, num_extra); 0 0 0
TINFL_GET_BITS(18, s, num_extra); 0 0 0
2654 0 s += "\03\03\013"[dist - 16];
2655 0 ▶ TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
Branch: 1 branch
BranchTrueFalseTotal
TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); 0 0 0
2656 0 counter += s;
2657 }
2658 0 ▶ if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
Branch: 1 branch
BranchTrueFalseTotal
if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) 0 0 0
2659 {
2660 0 TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED);
2661 }
2662 0 TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]);
2663 0 TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]);
2664 }
2665 }
2666 for (;;)
2667 0 {
2668 mz_uint8 *pSrc;
2669 for (;;)
2670 {
2671 0 ▶ if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
Branch: 2 branches
BranchTrueFalseTotal
if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) 0 0 0
if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) 0 0 0
2672 {
2673 0 ▶ TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0);
Branch: 14 branches
BranchTrueFalseTotal
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); 0 0 0
2674 0 ▶ if (counter >= 256)
Branch: 1 branch
BranchTrueFalseTotal
if (counter >= 256) 0 0 0
2675 0 break;
2676 0 while (pOut_buf_cur >= pOut_buf_end)
2677 {
2678 0 ▶ TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT);
Branch: 1 branch
BranchTrueFalseTotal
TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); 0 0 0
2679 }
2680 0 *pOut_buf_cur++ = (mz_uint8)counter;
2681 }
2682 else
2683 {
2684 int sym2;
2685 mz_uint code_len;
2686 #if TINFL_USE_64BIT_BITBUF
2687 0 ▶ if (num_bits < 30)
Branch: 1 branch
BranchTrueFalseTotal
if (num_bits < 30) 0 0 0
2688 {
2689 0 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
2690 0 pIn_buf_cur += 4;
2691 0 num_bits += 32;
2692 }
2693 #else
2694 if (num_bits < 15)
2695 {
2696 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
2697 pIn_buf_cur += 2;
2698 num_bits += 16;
2699 }
2700 #endif
2701 0 ▶ if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) 0 0 0
2702 0 code_len = sym2 >> 9;
2703 else
2704 {
2705 0 code_len = TINFL_FAST_LOOKUP_BITS;
2706 do
2707 {
2708 0 sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
2709 0 ▶ } while (sym2 < 0);
Branch: 1 branch
BranchTrueFalseTotal
} while (sym2 < 0); 0 0 0
2710 }
2711 0 counter = sym2;
2712 0 bit_buf >>= code_len;
2713 0 num_bits -= code_len;
2714 0 ▶ if (counter & 256)
Branch: 1 branch
BranchTrueFalseTotal
if (counter & 256) 0 0 0
2715 0 break;
2716  
2717 #if !TINFL_USE_64BIT_BITBUF
2718 if (num_bits < 15)
2719 {
2720 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
2721 pIn_buf_cur += 2;
2722 num_bits += 16;
2723 }
2724 #endif
2725 0 ▶ if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) 0 0 0
2726 0 code_len = sym2 >> 9;
2727 else
2728 {
2729 0 code_len = TINFL_FAST_LOOKUP_BITS;
2730 do
2731 {
2732 0 sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
2733 0 ▶ } while (sym2 < 0);
Branch: 1 branch
BranchTrueFalseTotal
} while (sym2 < 0); 0 0 0
2734 }
2735 0 bit_buf >>= code_len;
2736 0 num_bits -= code_len;
2737  
2738 0 pOut_buf_cur[0] = (mz_uint8)counter;
2739 0 ▶ if (sym2 & 256)
Branch: 1 branch
BranchTrueFalseTotal
if (sym2 & 256) 0 0 0
2740 {
2741 0 pOut_buf_cur++;
2742 0 counter = sym2;
2743 0 break;
2744 }
2745 0 pOut_buf_cur[1] = (mz_uint8)sym2;
2746 0 pOut_buf_cur += 2;
2747 }
2748 }
2749 0 ▶ if ((counter &= 511) == 256)
Branch: 1 branch
BranchTrueFalseTotal
if ((counter &= 511) == 256) 0 0 0
2750 0 break;
2751  
2752 0 num_extra = s_length_extra[counter - 257];
2753 0 counter = s_length_base[counter - 257];
2754 0 ▶ if (num_extra)
Branch: 1 branch
BranchTrueFalseTotal
if (num_extra) 0 0 0
2755 {
2756 mz_uint extra_bits;
2757 0 ▶ TINFL_GET_BITS(25, extra_bits, num_extra);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(25, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(25, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(25, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(25, extra_bits, num_extra); 0 0 0
2758 0 counter += extra_bits;
2759 }
2760  
2761 0 ▶ TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1);
Branch: 14 branches
BranchTrueFalseTotal
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); 0 0 0
2762 0 num_extra = s_dist_extra[dist];
2763 0 dist = s_dist_base[dist];
2764 0 ▶ if (num_extra)
Branch: 1 branch
BranchTrueFalseTotal
if (num_extra) 0 0 0
2765 {
2766 mz_uint extra_bits;
2767 0 ▶ TINFL_GET_BITS(27, extra_bits, num_extra);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(27, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(27, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(27, extra_bits, num_extra); 0 0 0
TINFL_GET_BITS(27, extra_bits, num_extra); 0 0 0
2768 0 dist += extra_bits;
2769 }
2770  
2771 0 dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
2772 0 ▶ if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
Branch: 4 branches
BranchTrueFalseTotal
if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) 0 0 0
if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) 0 0 0
if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) 0 0 0
if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) 0 0 0
2773 {
2774 0 TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED);
2775 }
2776  
2777 0 pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
2778  
2779 0 ▶ if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
Branch: 1 branch
BranchTrueFalseTotal
if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) 0 0 0
2780 {
2781 0 ▶ while (counter--)
Branch: 1 branch
BranchTrueFalseTotal
while (counter--) 0 0 0
2782 {
2783 0 while (pOut_buf_cur >= pOut_buf_end)
2784 {
2785 0 ▶ TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT);
Branch: 1 branch
BranchTrueFalseTotal
TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); 0 0 0
2786 }
2787 0 *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
2788 }
2789 0 continue;
2790 }
2791 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
2792 else if ((counter >= 9) && (counter <= dist))
2793 {
2794 const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
2795 do
2796 {
2797 #ifdef MINIZ_UNALIGNED_USE_MEMCPY
2798 memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32) * 2);
2799 #else
2800 ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
2801 ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
2802 #endif
2803 pOut_buf_cur += 8;
2804 } while ((pSrc += 8) < pSrc_end);
2805 if ((counter &= 7) < 3)
2806 {
2807 if (counter)
2808 {
2809 pOut_buf_cur[0] = pSrc[0];
2810 if (counter > 1)
2811 pOut_buf_cur[1] = pSrc[1];
2812 pOut_buf_cur += counter;
2813 }
2814 continue;
2815 }
2816 }
2817 #endif
2818 0 ▶ while (counter > 2)
Branch: 1 branch
BranchTrueFalseTotal
while (counter > 2) 0 0 0
2819 {
2820 0 pOut_buf_cur[0] = pSrc[0];
2821 0 pOut_buf_cur[1] = pSrc[1];
2822 0 pOut_buf_cur[2] = pSrc[2];
2823 0 pOut_buf_cur += 3;
2824 0 pSrc += 3;
2825 0 counter -= 3;
2826 }
2827 0 ▶ if (counter > 0)
Branch: 1 branch
BranchTrueFalseTotal
if (counter > 0) 0 0 0
2828 {
2829 0 pOut_buf_cur[0] = pSrc[0];
2830 0 ▶ if (counter > 1)
Branch: 1 branch
BranchTrueFalseTotal
if (counter > 1) 0 0 0
2831 0 pOut_buf_cur[1] = pSrc[1];
2832 0 pOut_buf_cur += counter;
2833 }
2834 }
2835 }
2836 0 ▶ } while (!(r->m_final & 1));
Branch: 1 branch
BranchTrueFalseTotal
} while (!(r->m_final & 1)); 0 0 0
2837  
2838 /* Ensure byte alignment and put back any bytes from the bitbuf if we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
2839 /* I'm being super conservative here. A number of simplifications can be made to the byte alignment part, and the Adler32 check shouldn't ever need to worry about reading from the bitbuf now. */
2840 0 ▶ TINFL_SKIP_BITS(32, num_bits & 7);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_SKIP_BITS(32, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(32, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(32, num_bits & 7); 0 0 0
TINFL_SKIP_BITS(32, num_bits & 7); 0 0 0
2841 0 ▶ while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
Branch: 2 branches
BranchTrueFalseTotal
while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) 0 0 0
while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) 0 0 0
2842 {
2843 0 --pIn_buf_cur;
2844 0 num_bits -= 8;
2845 }
2846 0 bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits);
2847 MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end of non-deflate/zlib streams with following data (such as gzip streams). */
2848  
2849 0 ▶ if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
Branch: 1 branch
BranchTrueFalseTotal
if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) 0 0 0
2850 {
2851 0 ▶ for (counter = 0; counter < 4; ++counter)
Branch: 1 branch
BranchTrueFalseTotal
for (counter = 0; counter < 4; ++counter) 0 0 0
2852 {
2853 mz_uint s;
2854 0 ▶ if (num_bits)
Branch: 1 branch
BranchTrueFalseTotal
if (num_bits) 0 0 0
2855 0 ▶ TINFL_GET_BITS(41, s, 8);
Branch: 4 branches
BranchTrueFalseTotal
TINFL_GET_BITS(41, s, 8); 0 0 0
TINFL_GET_BITS(41, s, 8); 0 0 0
TINFL_GET_BITS(41, s, 8); 0 0 0
TINFL_GET_BITS(41, s, 8); 0 0 0
2856 else
2857 0 ▶ TINFL_GET_BYTE(42, s);
Branch: 2 branches
BranchTrueFalseTotal
TINFL_GET_BYTE(42, s); 0 0 0
TINFL_GET_BYTE(42, s); 0 0 0
2858 0 r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
2859 }
2860 }
2861 0 TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE);
2862  
2863 TINFL_CR_FINISH
2864  
2865 0 common_exit:
2866 /* As long as we aren't telling the caller that we NEED more input to make forward progress: */
2867 /* Put back any bytes from the bitbuf in case we've looked ahead too far on gzip, or other Deflate streams followed by arbitrary data. */
2868 /* We need to be very careful here to NOT push back any bytes we definitely know we need to make forward progress, though, or we'll lock the caller up into an inf loop. */
2869 0 ▶ if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS))
Branch: 2 branches
BranchTrueFalseTotal
if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) 0 0 0
if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) 0 0 0
2870 {
2871 0 ▶ while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
Branch: 2 branches
BranchTrueFalseTotal
while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) 0 0 0
while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) 0 0 0
2872 {
2873 0 --pIn_buf_cur;
2874 0 num_bits -= 8;
2875 }
2876 }
2877 0 r->m_num_bits = num_bits;
2878 0 r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits);
2879 0 r->m_dist = dist;
2880 0 r->m_counter = counter;
2881 0 r->m_num_extra = num_extra;
2882 0 r->m_dist_from_out_buf_start = dist_from_out_buf_start;
2883 0 *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
2884 0 *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
2885 0 ▶ if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
Branch: 2 branches
BranchTrueFalseTotal
if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) 0 0 0
if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) 0 0 0
2886 {
2887 0 const mz_uint8 *ptr = pOut_buf_next;
2888 0 size_t buf_len = *pOut_buf_size;
2889 0 mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16;
2890 0 size_t block_len = buf_len % 5552;
2891 0 ▶ while (buf_len)
Branch: 1 branch
BranchTrueFalseTotal
while (buf_len) 0 0 0
2892 {
2893 0 ▶ for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i + 7 < block_len; i += 8, ptr += 8) 0 0 0
2894 {
2895 0 s1 += ptr[0], s2 += s1;
2896 0 s1 += ptr[1], s2 += s1;
2897 0 s1 += ptr[2], s2 += s1;
2898 0 s1 += ptr[3], s2 += s1;
2899 0 s1 += ptr[4], s2 += s1;
2900 0 s1 += ptr[5], s2 += s1;
2901 0 s1 += ptr[6], s2 += s1;
2902 0 s1 += ptr[7], s2 += s1;
2903 }
2904 0 ▶ for (; i < block_len; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (; i < block_len; ++i) 0 0 0
2905 0 s1 += *ptr++, s2 += s1;
2906 0 s1 %= 65521U, s2 %= 65521U;
2907 0 buf_len -= block_len;
2908 0 block_len = 5552;
2909 }
2910 0 r->m_check_adler32 = (s2 << 16) + s1;
2911 0 ▶ if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32))
Branch: 3 branches
BranchTrueFalseTotal
if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) 0 0 0
if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) 0 0 0
if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) 0 0 0
2912 0 status = TINFL_STATUS_ADLER32_MISMATCH;
2913 }
2914 0 return status;
2915 }
2916  
2917 /* Higher level helper functions. */
2918 0 void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
2919 {
2920 tinfl_decompressor decomp;
2921 0 void *pBuf = NULL, *pNew_buf;
2922 0 size_t src_buf_ofs = 0, out_buf_capacity = 0;
2923 0 *pOut_len = 0;
2924 0 tinfl_init(&decomp);
2925 for (;;)
2926 0 {
2927 0 size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
2928 0 tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, &dst_buf_size,
2929 0 ▶ (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
Branch: 1 branch
BranchTrueFalseTotal
(flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF); 0 0 0
2930 0 ▶ if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
Branch: 2 branches
BranchTrueFalseTotal
if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT)) 0 0 0
if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT)) 0 0 0
2931 {
2932 0 MZ_FREE(pBuf);
2933 0 *pOut_len = 0;
2934 0 return NULL;
2935 }
2936 0 src_buf_ofs += src_buf_size;
2937 0 *pOut_len += dst_buf_size;
2938 0 ▶ if (status == TINFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (status == TINFL_STATUS_DONE) 0 0 0
2939 0 break;
2940 0 new_out_buf_capacity = out_buf_capacity * 2;
2941 0 ▶ if (new_out_buf_capacity < 128)
Branch: 1 branch
BranchTrueFalseTotal
if (new_out_buf_capacity < 128) 0 0 0
2942 0 new_out_buf_capacity = 128;
2943 0 pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
2944 0 ▶ if (!pNew_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (!pNew_buf) 0 0 0
2945 {
2946 0 MZ_FREE(pBuf);
2947 0 *pOut_len = 0;
2948 0 return NULL;
2949 }
2950 0 pBuf = pNew_buf;
2951 0 out_buf_capacity = new_out_buf_capacity;
2952 }
2953 0 return pBuf;
2954 }
2955  
2956 0 size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
2957 {
2958 tinfl_decompressor decomp;
2959 tinfl_status status;
2960 0 tinfl_init(&decomp);
2961 0 status = tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf, &src_buf_len, (mz_uint8 *)pOut_buf, (mz_uint8 *)pOut_buf, &out_buf_len, (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF);
2962 0 ▶ return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
Branch: 1 branch
BranchTrueFalseTotal
return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len; 0 0 0
2963 }
2964  
2965 0 int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
2966 {
2967 0 int result = 0;
2968 tinfl_decompressor decomp;
2969 0 mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
2970 0 size_t in_buf_ofs = 0, dict_ofs = 0;
2971 0 ▶ if (!pDict)
Branch: 1 branch
BranchTrueFalseTotal
if (!pDict) 0 0 0
2972 0 return TINFL_STATUS_FAILED;
2973 0 memset(pDict, 0, TINFL_LZ_DICT_SIZE);
2974 0 tinfl_init(&decomp);
2975 for (;;)
2976 0 {
2977 0 size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
2978 0 tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
2979 0 (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
2980 0 in_buf_ofs += in_buf_size;
2981 0 ▶ if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
Branch: 2 branches
BranchTrueFalseTotal
if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user))) 0 0 0
if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user))) 0 0 0
2982 0 break;
2983 0 ▶ if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
Branch: 1 branch
BranchTrueFalseTotal
if (status != TINFL_STATUS_HAS_MORE_OUTPUT) 0 0 0
2984 {
2985 0 result = (status == TINFL_STATUS_DONE);
2986 0 break;
2987 }
2988 0 dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
2989 }
2990 0 MZ_FREE(pDict);
2991 0 *pIn_buf_size = in_buf_ofs;
2992 0 return result;
2993 }
2994  
2995 #ifndef MINIZ_NO_MALLOC
2996 0 tinfl_decompressor *tinfl_decompressor_alloc(void)
2997 {
2998 0 tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor));
2999 0 ▶ if (pDecomp)
Branch: 1 branch
BranchTrueFalseTotal
if (pDecomp) 0 0 0
3000 0 tinfl_init(pDecomp);
3001 0 return pDecomp;
3002 }
3003  
3004 0 void tinfl_decompressor_free(tinfl_decompressor *pDecomp)
3005 {
3006 0 MZ_FREE(pDecomp);
3007 0 }
3008 #endif
3009  
3010 #ifdef __cplusplus
3011 }
3012 #endif
3013  
3014 #endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
3015 /**************************************************************************
3016 *
3017 * Copyright 2013-2014 RAD Game Tools and Valve Software
3018 * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
3019 * Copyright 2016 Martin Raiber
3020 * All Rights Reserved.
3021 *
3022 * Permission is hereby granted, free of charge, to any person obtaining a copy
3023 * of this software and associated documentation files (the "Software"), to deal
3024 * in the Software without restriction, including without limitation the rights
3025 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
3026 * copies of the Software, and to permit persons to whom the Software is
3027 * furnished to do so, subject to the following conditions:
3028 *
3029 * The above copyright notice and this permission notice shall be included in
3030 * all copies or substantial portions of the Software.
3031 *
3032 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3033 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3034 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3035 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
3036 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
3037 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
3038 * THE SOFTWARE.
3039 *
3040 **************************************************************************/
3041  
3042  
3043 #ifndef MINIZ_NO_ARCHIVE_APIS
3044  
3045 #ifdef __cplusplus
3046 extern "C"
3047 {
3048 #endif
3049  
3050 /* ------------------- .ZIP archive reading */
3051  
3052 #ifdef MINIZ_NO_STDIO
3053 #define MZ_FILE void *
3054 #else
3055 #include <sys/stat.h>
3056  
3057 #if defined(_MSC_VER) || defined(__MINGW64__) || defined(__MINGW32__)
3058  
3059 #ifndef WIN32_LEAN_AND_MEAN
3060 #define WIN32_LEAN_AND_MEAN
3061 #endif
3062 #ifndef __cplusplus
3063 #define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
3064 #endif
3065 #ifndef NOMINMAX
3066 #define NOMINMAX
3067 #endif
3068 #include <windows.h>
3069  
3070 static WCHAR *mz_utf8z_to_widechar(const char *str)
3071 {
3072 int reqChars = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
3073 WCHAR *wStr = (WCHAR *)malloc(reqChars * sizeof(WCHAR));
3074 MultiByteToWideChar(CP_UTF8, 0, str, -1, wStr, reqChars);
3075 return wStr;
3076 }
3077  
3078 static FILE *mz_fopen(const char *pFilename, const char *pMode)
3079 {
3080 WCHAR *wFilename = mz_utf8z_to_widechar(pFilename);
3081 WCHAR *wMode = mz_utf8z_to_widechar(pMode);
3082 FILE *pFile = NULL;
3083 errno_t err = _wfopen_s(&pFile, wFilename, wMode);
3084 free(wFilename);
3085 free(wMode);
3086 return err ? NULL : pFile;
3087 }
3088  
3089 static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)
3090 {
3091 WCHAR *wPath = mz_utf8z_to_widechar(pPath);
3092 WCHAR *wMode = mz_utf8z_to_widechar(pMode);
3093 FILE *pFile = NULL;
3094 errno_t err = _wfreopen_s(&pFile, wPath, wMode, pStream);
3095 free(wPath);
3096 free(wMode);
3097 return err ? NULL : pFile;
3098 }
3099  
3100 #if defined(__MINGW32__)
3101 static int mz_stat(const char *path, struct _stat *buffer)
3102 {
3103 WCHAR *wPath = mz_utf8z_to_widechar(path);
3104 int res = _wstat(wPath, buffer);
3105 free(wPath);
3106 return res;
3107 }
3108 #else
3109 static int mz_stat64(const char *path, struct __stat64 *buffer)
3110 {
3111 WCHAR *wPath = mz_utf8z_to_widechar(path);
3112 int res = _wstat64(wPath, buffer);
3113 free(wPath);
3114 return res;
3115 }
3116 #endif
3117  
3118 #ifndef MINIZ_NO_TIME
3119 #include <sys/utime.h>
3120 #endif
3121 #define MZ_FOPEN mz_fopen
3122 #define MZ_FCLOSE fclose
3123 #define MZ_FREAD fread
3124 #define MZ_FWRITE fwrite
3125 #define MZ_FTELL64 _ftelli64
3126 #define MZ_FSEEK64 _fseeki64
3127 #if defined(__MINGW32__)
3128 #define MZ_FILE_STAT_STRUCT _stat
3129 #define MZ_FILE_STAT mz_stat
3130 #else
3131 #define MZ_FILE_STAT_STRUCT _stat64
3132 #define MZ_FILE_STAT mz_stat64
3133 #endif
3134 #define MZ_FFLUSH fflush
3135 #define MZ_FREOPEN mz_freopen
3136 #define MZ_DELETE_FILE remove
3137  
3138 #elif defined(__WATCOMC__)
3139 #ifndef MINIZ_NO_TIME
3140 #include <sys/utime.h>
3141 #endif
3142 #define MZ_FOPEN(f, m) fopen(f, m)
3143 #define MZ_FCLOSE fclose
3144 #define MZ_FREAD fread
3145 #define MZ_FWRITE fwrite
3146 #define MZ_FTELL64 _ftelli64
3147 #define MZ_FSEEK64 _fseeki64
3148 #define MZ_FILE_STAT_STRUCT stat
3149 #define MZ_FILE_STAT stat
3150 #define MZ_FFLUSH fflush
3151 #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
3152 #define MZ_DELETE_FILE remove
3153  
3154 #elif defined(__TINYC__)
3155 #ifndef MINIZ_NO_TIME
3156 #include <sys/utime.h>
3157 #endif
3158 #define MZ_FOPEN(f, m) fopen(f, m)
3159 #define MZ_FCLOSE fclose
3160 #define MZ_FREAD fread
3161 #define MZ_FWRITE fwrite
3162 #define MZ_FTELL64 ftell
3163 #define MZ_FSEEK64 fseek
3164 #define MZ_FILE_STAT_STRUCT stat
3165 #define MZ_FILE_STAT stat
3166 #define MZ_FFLUSH fflush
3167 #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
3168 #define MZ_DELETE_FILE remove
3169  
3170 #elif defined(__USE_LARGEFILE64) /* gcc, clang */
3171 #ifndef MINIZ_NO_TIME
3172 #include <utime.h>
3173 #endif
3174 #define MZ_FOPEN(f, m) fopen64(f, m)
3175 #define MZ_FCLOSE fclose
3176 #define MZ_FREAD fread
3177 #define MZ_FWRITE fwrite
3178 #define MZ_FTELL64 ftello64
3179 #define MZ_FSEEK64 fseeko64
3180 #define MZ_FILE_STAT_STRUCT stat64
3181 #define MZ_FILE_STAT stat64
3182 #define MZ_FFLUSH fflush
3183 #define MZ_FREOPEN(p, m, s) freopen64(p, m, s)
3184 #define MZ_DELETE_FILE remove
3185  
3186 #elif defined(__APPLE__) || defined(__FreeBSD__) || (defined(__linux__) && defined(__x86_64__))
3187 #ifndef MINIZ_NO_TIME
3188 #include <utime.h>
3189 #endif
3190 #define MZ_FOPEN(f, m) fopen(f, m)
3191 #define MZ_FCLOSE fclose
3192 #define MZ_FREAD fread
3193 #define MZ_FWRITE fwrite
3194 #define MZ_FTELL64 ftello
3195 #define MZ_FSEEK64 fseeko
3196 #define MZ_FILE_STAT_STRUCT stat
3197 #define MZ_FILE_STAT stat
3198 #define MZ_FFLUSH fflush
3199 #define MZ_FREOPEN(p, m, s) freopen(p, m, s)
3200 #define MZ_DELETE_FILE remove
3201  
3202 #else
3203 #pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")
3204 #ifndef MINIZ_NO_TIME
3205 #include <utime.h>
3206 #endif
3207 #define MZ_FOPEN(f, m) fopen(f, m)
3208 #define MZ_FCLOSE fclose
3209 #define MZ_FREAD fread
3210 #define MZ_FWRITE fwrite
3211 #ifdef __STRICT_ANSI__
3212 #define MZ_FTELL64 ftell
3213 #define MZ_FSEEK64 fseek
3214 #else
3215 #define MZ_FTELL64 ftello
3216 #define MZ_FSEEK64 fseeko
3217 #endif
3218 #define MZ_FILE_STAT_STRUCT stat
3219 #define MZ_FILE_STAT stat
3220 #define MZ_FFLUSH fflush
3221 #define MZ_FREOPEN(f, m, s) freopen(f, m, s)
3222 #define MZ_DELETE_FILE remove
3223 #endif /* #ifdef _MSC_VER */
3224 #endif /* #ifdef MINIZ_NO_STDIO */
3225  
3226 #define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))
3227  
3228 /* Various ZIP archive enums. To completely avoid cross platform compiler alignment and platform endian issues, miniz.c doesn't use structs for any of this stuff. */
3229 enum
3230 {
3231 /* ZIP archive identifiers and record sizes */
3232 MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50,
3233 MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50,
3234 MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50,
3235 MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,
3236 MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,
3237 MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,
3238  
3239 /* ZIP64 archive identifier and record sizes */
3240 MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,
3241 MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,
3242 MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,
3243 MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,
3244 MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,
3245 MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,
3246 MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,
3247 MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,
3248  
3249 /* Central directory header record offsets */
3250 MZ_ZIP_CDH_SIG_OFS = 0,
3251 MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,
3252 MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6,
3253 MZ_ZIP_CDH_BIT_FLAG_OFS = 8,
3254 MZ_ZIP_CDH_METHOD_OFS = 10,
3255 MZ_ZIP_CDH_FILE_TIME_OFS = 12,
3256 MZ_ZIP_CDH_FILE_DATE_OFS = 14,
3257 MZ_ZIP_CDH_CRC32_OFS = 16,
3258 MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20,
3259 MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24,
3260 MZ_ZIP_CDH_FILENAME_LEN_OFS = 28,
3261 MZ_ZIP_CDH_EXTRA_LEN_OFS = 30,
3262 MZ_ZIP_CDH_COMMENT_LEN_OFS = 32,
3263 MZ_ZIP_CDH_DISK_START_OFS = 34,
3264 MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36,
3265 MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38,
3266 MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42,
3267  
3268 /* Local directory header offsets */
3269 MZ_ZIP_LDH_SIG_OFS = 0,
3270 MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4,
3271 MZ_ZIP_LDH_BIT_FLAG_OFS = 6,
3272 MZ_ZIP_LDH_METHOD_OFS = 8,
3273 MZ_ZIP_LDH_FILE_TIME_OFS = 10,
3274 MZ_ZIP_LDH_FILE_DATE_OFS = 12,
3275 MZ_ZIP_LDH_CRC32_OFS = 14,
3276 MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18,
3277 MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22,
3278 MZ_ZIP_LDH_FILENAME_LEN_OFS = 26,
3279 MZ_ZIP_LDH_EXTRA_LEN_OFS = 28,
3280 MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3,
3281  
3282 /* End of central directory offsets */
3283 MZ_ZIP_ECDH_SIG_OFS = 0,
3284 MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4,
3285 MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6,
3286 MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8,
3287 MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10,
3288 MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,
3289 MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,
3290 MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,
3291  
3292 /* ZIP64 End of central directory locator offsets */
3293 MZ_ZIP64_ECDL_SIG_OFS = 0, /* 4 bytes */
3294 MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4, /* 4 bytes */
3295 MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8, /* 8 bytes */
3296 MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */
3297  
3298 /* ZIP64 End of central directory header offsets */
3299 MZ_ZIP64_ECDH_SIG_OFS = 0, /* 4 bytes */
3300 MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4, /* 8 bytes */
3301 MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12, /* 2 bytes */
3302 MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14, /* 2 bytes */
3303 MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16, /* 4 bytes */
3304 MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20, /* 4 bytes */
3305 MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */
3306 MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32, /* 8 bytes */
3307 MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40, /* 8 bytes */
3308 MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48, /* 8 bytes */
3309 MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,
3310 MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,
3311 MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,
3312 MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,
3313 MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,
3314 MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,
3315 MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11
3316 };
3317  
3318 typedef struct
3319 {
3320 void *m_p;
3321 size_t m_size, m_capacity;
3322 mz_uint m_element_size;
3323 } mz_zip_array;
3324  
3325 struct mz_zip_internal_state_tag
3326 {
3327 mz_zip_array m_central_dir;
3328 mz_zip_array m_central_dir_offsets;
3329 mz_zip_array m_sorted_central_dir_offsets;
3330  
3331 /* The flags passed in when the archive is initially opened. */
3332 mz_uint32 m_init_flags;
3333  
3334 /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. */
3335 mz_bool m_zip64;
3336  
3337 /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 will also be slammed to true too, even if we didn't find a zip64 end of central dir header, etc.) */
3338 mz_bool m_zip64_has_extended_info_fields;
3339  
3340 /* These fields are used by the file, FILE, memory, and memory/heap read/write helpers. */
3341 MZ_FILE *m_pFile;
3342 mz_uint64 m_file_archive_start_ofs;
3343  
3344 void *m_pMem;
3345 size_t m_mem_size;
3346 size_t m_mem_capacity;
3347 };
3348  
3349 #define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size
3350  
3351 #if defined(DEBUG) || defined(_DEBUG)
3352 static MZ_FORCEINLINE mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index)
3353 {
3354 MZ_ASSERT(index < pArray->m_size);
3355 return index;
3356 }
3357 #define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)]
3358 #else
3359 #define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index]
3360 #endif
3361  
3362 static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)
3363 {
3364 0 memset(pArray, 0, sizeof(mz_zip_array));
3365 0 pArray->m_element_size = element_size;
3366 0 }
3367  
3368 static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
3369 {
3370 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);
3371 0 memset(pArray, 0, sizeof(mz_zip_array));
3372 0 }
3373  
3374 0 static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)
3375 {
3376 void *pNew_p;
3377 0 size_t new_capacity = min_new_capacity;
3378 MZ_ASSERT(pArray->m_element_size);
3379 0 ▶ if (pArray->m_capacity >= min_new_capacity)
Branch: 1 branch
BranchTrueFalseTotal
if (pArray->m_capacity >= min_new_capacity) 0 0 0
3380 0 return MZ_TRUE;
3381 0 ▶ if (growing)
Branch: 1 branch
BranchTrueFalseTotal
if (growing) 0 0 0
3382 {
3383 0 ▶ new_capacity = MZ_MAX(1, pArray->m_capacity);
Branch: 1 branch
BranchTrueFalseTotal
new_capacity = MZ_MAX(1, pArray->m_capacity); 0 0 0
3384 0 ▶ while (new_capacity < min_new_capacity)
Branch: 1 branch
BranchTrueFalseTotal
while (new_capacity < min_new_capacity) 0 0 0
3385 0 new_capacity *= 2;
3386 }
3387 0 ▶ if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity))) 0 0 0
3388 0 return MZ_FALSE;
3389 0 pArray->m_p = pNew_p;
3390 0 pArray->m_capacity = new_capacity;
3391 0 return MZ_TRUE;
3392 }
3393  
3394 static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)
3395 {
3396 0 if (new_capacity > pArray->m_capacity)
3397 {
3398 0 ▶ if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing))
Branch: 3 branches
BranchTrueFalseTotal
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) 0 0 0
3399 0 return MZ_FALSE;
3400 }
3401 0 return MZ_TRUE;
3402 }
3403  
3404 static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
3405 {
3406 0 ▶ if (new_size > pArray->m_capacity)
Branch: 1 branch
BranchTrueFalseTotal
if (new_size > pArray->m_capacity) 0 0 0
3407 {
3408 0 ▶ if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing))
Branch: 28 branches
BranchTrueFalseTotal
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) 0 0 0
3409 0 return MZ_FALSE;
3410 }
3411 0 pArray->m_size = new_size;
3412 0 return MZ_TRUE;
3413 }
3414  
3415 static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
3416 {
3417 0 return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE);
3418 }
3419  
3420 static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
3421 {
3422 0 size_t orig_size = pArray->m_size;
3423 0 ▶ if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE))
Branch: 15 branches
BranchTrueFalseTotal
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) 0 0 0
3424 0 return MZ_FALSE;
3425 0 ▶ if (n > 0)
Branch: 15 branches
BranchTrueFalseTotal
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
if (n > 0) 0 0 0
3426 0 memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size);
3427 0 return MZ_TRUE;
3428 }
3429  
3430 #ifndef MINIZ_NO_TIME
3431 0 static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date)
3432 {
3433 struct tm tm;
3434 0 memset(&tm, 0, sizeof(tm));
3435 0 tm.tm_isdst = -1;
3436 0 tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;
3437 0 tm.tm_mon = ((dos_date >> 5) & 15) - 1;
3438 0 tm.tm_mday = dos_date & 31;
3439 0 tm.tm_hour = (dos_time >> 11) & 31;
3440 0 tm.tm_min = (dos_time >> 5) & 63;
3441 0 tm.tm_sec = (dos_time << 1) & 62;
3442 0 return mktime(&tm);
3443 }
3444  
3445 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
3446 0 static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
3447 {
3448 #ifdef _MSC_VER
3449 struct tm tm_struct;
3450 struct tm *tm = &tm_struct;
3451 errno_t err = localtime_s(tm, &time);
3452 if (err)
3453 {
3454 *pDOS_date = 0;
3455 *pDOS_time = 0;
3456 return;
3457 }
3458 #else
3459 0 struct tm *tm = localtime(&time);
3460 #endif /* #ifdef _MSC_VER */
3461  
3462 0 *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));
3463 0 *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);
3464 0 }
3465 #endif /* MINIZ_NO_ARCHIVE_WRITING_APIS */
3466  
3467 #ifndef MINIZ_NO_STDIO
3468 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
3469 static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)
3470 {
3471 struct MZ_FILE_STAT_STRUCT file_stat;
3472  
3473 /* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */
3474 if (MZ_FILE_STAT(pFilename, &file_stat) != 0)
3475 return MZ_FALSE;
3476  
3477 *pTime = file_stat.st_mtime;
3478  
3479 return MZ_TRUE;
3480 }
3481 #endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS*/
3482  
3483 static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time)
3484 {
3485 struct utimbuf t;
3486  
3487 memset(&t, 0, sizeof(t));
3488 t.actime = access_time;
3489 t.modtime = modified_time;
3490  
3491 return !utime(pFilename, &t);
3492 }
3493 #endif /* #ifndef MINIZ_NO_STDIO */
3494 #endif /* #ifndef MINIZ_NO_TIME */
3495  
3496 static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)
3497 {
3498 0 ▶ if (pZip)
Branch: 210 branches
BranchTrueFalseTotal
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
if (pZip) 0 0 0
3499 0 pZip->m_last_error = err_num;
3500 0 return MZ_FALSE;
3501 }
3502  
3503 0 static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
3504 {
3505 (void)flags;
3506 0 ▶ if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
Branch: 3 branches
BranchTrueFalseTotal
if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
3507 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
3508  
3509 0 ▶ if (!pZip->m_pAlloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pAlloc) 0 0 0
3510 0 pZip->m_pAlloc = miniz_def_alloc_func;
3511 0 ▶ if (!pZip->m_pFree)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pFree) 0 0 0
3512 0 pZip->m_pFree = miniz_def_free_func;
3513 0 ▶ if (!pZip->m_pRealloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pRealloc) 0 0 0
3514 0 pZip->m_pRealloc = miniz_def_realloc_func;
3515  
3516 0 pZip->m_archive_size = 0;
3517 0 pZip->m_central_directory_file_ofs = 0;
3518 0 pZip->m_total_files = 0;
3519 0 pZip->m_last_error = MZ_ZIP_NO_ERROR;
3520  
3521 0 ▶ if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) 0 0 0
3522 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
3523  
3524 0 memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
3525 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
3526 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
3527 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
3528 0 pZip->m_pState->m_init_flags = flags;
3529 0 pZip->m_pState->m_zip64 = MZ_FALSE;
3530 0 pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;
3531  
3532 0 pZip->m_zip_mode = MZ_ZIP_MODE_READING;
3533  
3534 0 return MZ_TRUE;
3535 }
3536  
3537 static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)
3538 {
3539 0 const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
3540 0 const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));
3541 0 mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);
3542 0 mz_uint8 l = 0, r = 0;
3543 0 pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
3544 0 pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
3545 0 pE = pL + MZ_MIN(l_len, r_len);
3546 0 ▶ while (pL < pE)
Branch: 4 branches
BranchTrueFalseTotal
while (pL < pE) 0 0 0
while (pL < pE) 0 0 0
while (pL < pE) 0 0 0
while (pL < pE) 0 0 0
3547 {
3548 0 ▶ if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
Branch: 20 branches
BranchTrueFalseTotal
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
3549 0 break;
3550 0 pL++;
3551 0 pR++;
3552 }
3553 0 ▶ return (pL == pE) ? (l_len < r_len) : (l < r);
Branch: 4 branches
BranchTrueFalseTotal
return (pL == pE) ? (l_len < r_len) : (l < r); 0 0 0
return (pL == pE) ? (l_len < r_len) : (l < r); 0 0 0
return (pL == pE) ? (l_len < r_len) : (l < r); 0 0 0
return (pL == pE) ? (l_len < r_len) : (l < r); 0 0 0
3554 }
3555  
3556 #define MZ_SWAP_UINT32(a, b) \
3557 do \
3558 { \
3559 mz_uint32 t = a; \
3560 a = b; \
3561 b = t; \
3562 } \
3563 MZ_MACRO_END
3564  
3565 /* Heap sort of lowercased filenames, used to help accelerate plain central directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), but it could allocate memory.) */
3566 0 static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)
3567 {
3568 0 mz_zip_internal_state *pState = pZip->m_pState;
3569 0 const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
3570 0 const mz_zip_array *pCentral_dir = &pState->m_central_dir;
3571 mz_uint32 *pIndices;
3572 mz_uint32 start, end;
3573 0 const mz_uint32 size = pZip->m_total_files;
3574  
3575 0 ▶ if (size <= 1U)
Branch: 1 branch
BranchTrueFalseTotal
if (size <= 1U) 0 0 0
3576 0 return;
3577  
3578 0 pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
3579  
3580 0 start = (size - 2U) >> 1U;
3581 for (;;)
3582 0 {
3583 0 mz_uint64 child, root = start;
3584 for (;;)
3585 {
3586 0 ▶ if ((child = (root << 1U) + 1U) >= size)
Branch: 1 branch
BranchTrueFalseTotal
if ((child = (root << 1U) + 1U) >= size) 0 0 0
3587 0 break;
3588 0 ▶ child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])));
Branch: 2 branches
BranchTrueFalseTotal
child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]))); 0 0 0
child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]))); 0 0 0
3589 0 ▶ if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child])) 0 0 0
3590 0 break;
3591 0 MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
3592 0 root = child;
3593 }
3594 0 ▶ if (!start)
Branch: 1 branch
BranchTrueFalseTotal
if (!start) 0 0 0
3595 0 break;
3596 0 start--;
3597 }
3598  
3599 0 end = size - 1;
3600 0 ▶ while (end > 0)
Branch: 1 branch
BranchTrueFalseTotal
while (end > 0) 0 0 0
3601 {
3602 0 mz_uint64 child, root = 0;
3603 0 MZ_SWAP_UINT32(pIndices[end], pIndices[0]);
3604 for (;;)
3605 {
3606 0 ▶ if ((child = (root << 1U) + 1U) >= end)
Branch: 1 branch
BranchTrueFalseTotal
if ((child = (root << 1U) + 1U) >= end) 0 0 0
3607 0 break;
3608 0 ▶ child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));
Branch: 2 branches
BranchTrueFalseTotal
child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])); 0 0 0
child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])); 0 0 0
3609 0 ▶ if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child])) 0 0 0
3610 0 break;
3611 0 MZ_SWAP_UINT32(pIndices[root], pIndices[child]);
3612 0 root = child;
3613 }
3614 0 end--;
3615 }
3616 }
3617  
3618 0 static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)
3619 {
3620 mz_int64 cur_file_ofs;
3621 mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
3622 0 mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
3623  
3624 /* Basic sanity checks - reject files which are too small */
3625 0 ▶ if (pZip->m_archive_size < record_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_archive_size < record_size) 0 0 0
3626 0 return MZ_FALSE;
3627  
3628 /* Find the record by scanning the file from the end towards the beginning. */
3629 0 cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);
3630 for (;;)
3631 0 {
3632 0 ▶ int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);
Branch: 1 branch
BranchTrueFalseTotal
int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs); 0 0 0
3633  
3634 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n) 0 0 0
3635 0 return MZ_FALSE;
3636  
3637 0 ▶ for (i = n - 4; i >= 0; --i)
Branch: 1 branch
BranchTrueFalseTotal
for (i = n - 4; i >= 0; --i) 0 0 0
3638 {
3639 0 mz_uint s = MZ_READ_LE32(pBuf + i);
3640 0 ▶ if (s == record_sig)
Branch: 1 branch
BranchTrueFalseTotal
if (s == record_sig) 0 0 0
3641 {
3642 0 ▶ if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size) 0 0 0
3643 0 break;
3644 }
3645 }
3646  
3647 0 ▶ if (i >= 0)
Branch: 1 branch
BranchTrueFalseTotal
if (i >= 0) 0 0 0
3648 {
3649 0 cur_file_ofs += i;
3650 0 break;
3651 }
3652  
3653 /* Give up if we've searched the entire file, or we've gone back "too far" (~64kb) */
3654 0 ▶ if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= ((mz_uint64)(MZ_UINT16_MAX) + record_size)))
Branch: 2 branches
BranchTrueFalseTotal
if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= ((mz_uint64)(MZ_UINT16_MAX) + record_size))) 0 0 0
if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= ((mz_uint64)(MZ_UINT16_MAX) + record_size))) 0 0 0
3655 0 return MZ_FALSE;
3656  
3657 0 ▶ cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
Branch: 1 branch
BranchTrueFalseTotal
cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0); 0 0 0
3658 }
3659  
3660 0 *pOfs = cur_file_ofs;
3661 0 return MZ_TRUE;
3662 }
3663  
3664 0 static mz_bool mz_zip_reader_eocd64_valid(mz_zip_archive *pZip, uint64_t offset, uint8_t *buf)
3665 {
3666 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, offset, buf, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, offset, buf, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
3667 {
3668 0 ▶ if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) 0 0 0
3669 {
3670 0 return MZ_TRUE;
3671 }
3672 }
3673  
3674 0 return MZ_FALSE;
3675 }
3676  
3677 0 static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)
3678 {
3679 0 mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;
3680 0 mz_uint64 cdir_ofs = 0, eocd_ofs = 0, archive_ofs = 0;
3681 0 mz_int64 cur_file_ofs = 0;
3682 const mz_uint8 *p;
3683  
3684 mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];
3685 0 mz_uint8 *pBuf = (mz_uint8 *)buf_u32;
3686 0 mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);
3687 mz_uint32 zip64_end_of_central_dir_locator_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
3688 0 mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;
3689  
3690 mz_uint32 zip64_end_of_central_dir_header_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
3691 0 mz_uint8 *pZip64_end_of_central_dir = (mz_uint8 *)zip64_end_of_central_dir_header_u32;
3692  
3693 0 mz_uint64 zip64_end_of_central_dir_ofs = 0;
3694  
3695 /* Basic sanity checks - reject files which are too small, and check the first 4 bytes of the file to make sure a local header is there. */
3696 0 ▶ if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
3697 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
3698  
3699 0 ▶ if (!mz_zip_reader_locate_header_sig(pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_header_sig(pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs)) 0 0 0
3700 0 return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
3701  
3702 0 eocd_ofs = cur_file_ofs;
3703 /* Read and verify the end of central directory record. */
3704 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
3705 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
3706  
3707 0 ▶ if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) 0 0 0
3708 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
3709  
3710 0 ▶ if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
Branch: 1 branch
BranchTrueFalseTotal
if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
3711 {
3712 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, pZip64_locator, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, pZip64_locator, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) 0 0 0
3713 {
3714 0 ▶ if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) 0 0 0
3715 {
3716 0 pZip->m_pState->m_zip64 = MZ_TRUE;
3717 }
3718 }
3719 }
3720  
3721 0 ▶ if (pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_zip64) 0 0 0
3722 {
3723 /* Try locating the EOCD64 right before the EOCD64 locator. This works even
3724 * when the effective start of the zip header is not yet known. */
3725 0 ▶ if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
Branch: 1 branch
BranchTrueFalseTotal
if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + 0 0 0
3726 MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
3727 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
3728  
3729 0 zip64_end_of_central_dir_ofs = cur_file_ofs -
3730 0 MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE -
3731 MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
3732  
3733 0 ▶ if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, 0 0 0
3734 pZip64_end_of_central_dir))
3735 {
3736 /* That failed, try reading where the locator tells us to. */
3737 0 zip64_end_of_central_dir_ofs = MZ_READ_LE64(
3738 pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);
3739  
3740 0 if (zip64_end_of_central_dir_ofs >
3741 0 ▶ (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))
Branch: 1 branch
BranchTrueFalseTotal
(pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
3742 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
3743  
3744 0 ▶ if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, 0 0 0
3745 pZip64_end_of_central_dir))
3746 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
3747 }
3748 }
3749  
3750 0 pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);
3751 0 cdir_entries_on_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
3752 0 num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);
3753 0 cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);
3754 0 cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);
3755 0 cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);
3756  
3757 0 ▶ if (pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_zip64) 0 0 0
3758 {
3759 0 mz_uint32 zip64_total_num_of_disks = MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);
3760 0 mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);
3761 0 mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);
3762 0 mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);
3763 0 mz_uint64 zip64_size_of_central_directory = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);
3764  
3765 0 ▶ if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))
Branch: 1 branch
BranchTrueFalseTotal
if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12)) 0 0 0
3766 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3767  
3768 0 ▶ if (zip64_total_num_of_disks != 1U)
Branch: 1 branch
BranchTrueFalseTotal
if (zip64_total_num_of_disks != 1U) 0 0 0
3769 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
3770  
3771 /* Check for miniz's practical limits */
3772 0 ▶ if (zip64_cdir_total_entries > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (zip64_cdir_total_entries > MZ_UINT32_MAX) 0 0 0
3773 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
3774  
3775 0 pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;
3776  
3777 0 ▶ if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX) 0 0 0
3778 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
3779  
3780 0 cdir_entries_on_this_disk = (mz_uint32)zip64_cdir_total_entries_on_this_disk;
3781  
3782 /* Check for miniz's current practical limits (sorry, this should be enough for millions of files) */
3783 0 ▶ if (zip64_size_of_central_directory > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (zip64_size_of_central_directory > MZ_UINT32_MAX) 0 0 0
3784 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
3785  
3786 0 cdir_size = (mz_uint32)zip64_size_of_central_directory;
3787  
3788 0 num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);
3789  
3790 0 cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);
3791  
3792 0 cdir_ofs = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);
3793 }
3794  
3795 0 ▶ if (pZip->m_total_files != cdir_entries_on_this_disk)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files != cdir_entries_on_this_disk) 0 0 0
3796 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
3797  
3798 0 ▶ if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))
Branch: 3 branches
BranchTrueFalseTotal
if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1))) 0 0 0
if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1))) 0 0 0
if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1))) 0 0 0
3799 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
3800  
3801 0 ▶ if (cdir_size < (mz_uint64)pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (cdir_size < (mz_uint64)pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) 0 0 0
3802 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3803  
3804 0 ▶ if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size) 0 0 0
3805 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3806  
3807 0 ▶ if (eocd_ofs < cdir_ofs + cdir_size)
Branch: 1 branch
BranchTrueFalseTotal
if (eocd_ofs < cdir_ofs + cdir_size) 0 0 0
3808 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3809  
3810 /* The end of central dir follows the central dir, unless the zip file has
3811 * some trailing data (e.g. it is appended to an executable file). */
3812 0 archive_ofs = eocd_ofs - (cdir_ofs + cdir_size);
3813 0 ▶ if (pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_zip64) 0 0 0
3814 {
3815 0 ▶ if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
Branch: 1 branch
BranchTrueFalseTotal
if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + 0 0 0
3816 MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
3817 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3818  
3819 0 archive_ofs -= MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
3820 MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
3821 }
3822  
3823 /* Update the archive start position, but only if not specified. */
3824 0 ▶ if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE || pZip->m_zip_type == MZ_ZIP_TYPE_CFILE ||
Branch: 2 branches
BranchTrueFalseTotal
if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE || pZip->m_zip_type == MZ_ZIP_TYPE_CFILE || 0 0 0
if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE || pZip->m_zip_type == MZ_ZIP_TYPE_CFILE || 0 0 0
3825 0 ▶ pZip->m_zip_type == MZ_ZIP_TYPE_USER) && pZip->m_pState->m_file_archive_start_ofs == 0)
Branch: 2 branches
BranchTrueFalseTotal
pZip->m_zip_type == MZ_ZIP_TYPE_USER) && pZip->m_pState->m_file_archive_start_ofs == 0) 0 0 0
pZip->m_zip_type == MZ_ZIP_TYPE_USER) && pZip->m_pState->m_file_archive_start_ofs == 0) 0 0 0
3826 {
3827 0 pZip->m_pState->m_file_archive_start_ofs = archive_ofs;
3828 0 pZip->m_archive_size -= archive_ofs;
3829 }
3830  
3831 0 pZip->m_central_directory_file_ofs = cdir_ofs;
3832  
3833 0 ▶ if (pZip->m_total_files)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files) 0 0 0
3834 {
3835 mz_uint i, n;
3836 /* Read the entire central directory into a heap block, and allocate another heap block to hold the unsorted central dir file record offsets, and possibly another to hold the sorted indices. */
3837 0 ▶ if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) ||
Branch: 2 branches
BranchTrueFalseTotal
if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) || 0 0 0
if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) || 0 0 0
3838 0 ▶ (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE)))
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE))) 0 0 0
(!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE))) 0 0 0
3839 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
3840  
3841 0 ▶ if (sort_central_dir)
Branch: 1 branch
BranchTrueFalseTotal
if (sort_central_dir) 0 0 0
3842 {
3843 0 ▶ if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE)) 0 0 0
if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE)) 0 0 0
3844 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
3845 }
3846  
3847 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size) 0 0 0
3848 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
3849  
3850 /* Now create an index into the central directory file records, do some basic sanity checking on each record */
3851 0 p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;
3852 0 ▶ for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i)
Branch: 1 branch
BranchTrueFalseTotal
for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) 0 0 0
3853 {
3854 mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size;
3855 mz_uint64 comp_size, decomp_size, local_header_ofs;
3856  
3857 0 ▶ if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))
Branch: 2 branches
BranchTrueFalseTotal
if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) 0 0 0
if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) 0 0 0
3858 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3859  
3860 0 MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, i) = (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);
3861  
3862 0 ▶ if (sort_central_dir)
Branch: 1 branch
BranchTrueFalseTotal
if (sort_central_dir) 0 0 0
3863 0 MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i;
3864  
3865 0 comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
3866 0 decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
3867 0 local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
3868 0 filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
3869 0 ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
3870  
3871 0 ▶ if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && 0 0 0
if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && 0 0 0
3872 0 (ext_data_size) &&
3873 0 ▶ (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX))
Branch: 1 branch
BranchTrueFalseTotal
(MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX)) 0 0 0
3874 {
3875 /* Attempt to find zip64 extended information field in the entry's extra data */
3876 0 mz_uint32 extra_size_remaining = ext_data_size;
3877  
3878 0 ▶ if (extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining) 0 0 0
3879 {
3880 const mz_uint8 *pExtra_data;
3881 0 void *buf = NULL;
3882  
3883 0 ▶ if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n) 0 0 0
3884 {
3885 0 buf = MZ_MALLOC(ext_data_size);
3886 0 ▶ if (buf == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (buf == NULL) 0 0 0
3887 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
3888  
3889 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size, buf, ext_data_size) != ext_data_size) 0 0 0
3890 {
3891 0 ▶ MZ_FREE(buf);
Branch: 1 branch
BranchTrueFalseTotal
MZ_FREE(buf); 0 0 0
3892 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
3893 }
3894  
3895 0 pExtra_data = (mz_uint8 *)buf;
3896 }
3897 else
3898 {
3899 0 pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;
3900 }
3901  
3902 do
3903 {
3904 mz_uint32 field_id;
3905 mz_uint32 field_data_size;
3906  
3907 0 ▶ if (extra_size_remaining < (sizeof(mz_uint16) * 2))
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) 0 0 0
3908 {
3909 0 ▶ MZ_FREE(buf);
Branch: 1 branch
BranchTrueFalseTotal
MZ_FREE(buf); 0 0 0
3910 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3911 }
3912  
3913 0 field_id = MZ_READ_LE16(pExtra_data);
3914 0 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
3915  
3916 0 ▶ if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) 0 0 0
3917 {
3918 0 ▶ MZ_FREE(buf);
Branch: 1 branch
BranchTrueFalseTotal
MZ_FREE(buf); 0 0 0
3919 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3920 }
3921  
3922 0 ▶ if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
Branch: 1 branch
BranchTrueFalseTotal
if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) 0 0 0
3923 {
3924 /* Ok, the archive didn't have any zip64 headers but it uses a zip64 extended information field so mark it as zip64 anyway (this can occur with infozip's zip util when it reads compresses files from stdin). */
3925 0 pZip->m_pState->m_zip64 = MZ_TRUE;
3926 0 pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;
3927 0 break;
3928 }
3929  
3930 0 pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
3931 0 extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
3932 0 ▶ } while (extra_size_remaining);
Branch: 1 branch
BranchTrueFalseTotal
} while (extra_size_remaining); 0 0 0
3933  
3934 0 MZ_FREE(buf);
3935 }
3936 }
3937  
3938 /* I've seen archives that aren't marked as zip64 that uses zip64 ext data, argh */
3939 0 ▶ if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX))
Branch: 2 branches
BranchTrueFalseTotal
if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) 0 0 0
if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) 0 0 0
3940 {
3941 0 ▶ if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size))
Branch: 4 branches
BranchTrueFalseTotal
if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size)) 0 0 0
if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size)) 0 0 0
if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size)) 0 0 0
if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size)) 0 0 0
3942 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3943 }
3944  
3945 0 disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);
3946 0 ▶ if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1)))
Branch: 3 branches
BranchTrueFalseTotal
if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1))) 0 0 0
if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1))) 0 0 0
if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1))) 0 0 0
3947 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);
3948  
3949 0 ▶ if (comp_size != MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (comp_size != MZ_UINT32_MAX) 0 0 0
3950 {
3951 0 ▶ if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size) 0 0 0
3952 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3953 }
3954  
3955 0 bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
3956 0 ▶ if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)
Branch: 1 branch
BranchTrueFalseTotal
if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED) 0 0 0
3957 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
3958  
3959 0 ▶ if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n)
Branch: 1 branch
BranchTrueFalseTotal
if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n) 0 0 0
3960 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
3961  
3962 0 n -= total_header_size;
3963 0 p += total_header_size;
3964 }
3965 }
3966  
3967 0 ▶ if (sort_central_dir)
Branch: 1 branch
BranchTrueFalseTotal
if (sort_central_dir) 0 0 0
3968 0 mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);
3969  
3970 0 return MZ_TRUE;
3971 }
3972  
3973 0 void mz_zip_zero_struct(mz_zip_archive *pZip)
3974 {
3975 0 ▶ if (pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip) 0 0 0
3976 0 MZ_CLEAR_PTR(pZip);
3977 0 }
3978  
3979 0 static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
3980 {
3981 0 mz_bool status = MZ_TRUE;
3982  
3983 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
3984 0 return MZ_FALSE;
3985  
3986 0 ▶ if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
3987 {
3988 0 ▶ if (set_last_error)
Branch: 1 branch
BranchTrueFalseTotal
if (set_last_error) 0 0 0
3989 0 pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;
3990  
3991 0 return MZ_FALSE;
3992 }
3993  
3994 0 ▶ if (pZip->m_pState)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState) 0 0 0
3995 {
3996 0 mz_zip_internal_state *pState = pZip->m_pState;
3997 0 pZip->m_pState = NULL;
3998  
3999 0 mz_zip_array_clear(pZip, &pState->m_central_dir);
4000 0 mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
4001 0 mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
4002  
4003 #ifndef MINIZ_NO_STDIO
4004 if (pState->m_pFile)
4005 {
4006 if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
4007 {
4008 if (MZ_FCLOSE(pState->m_pFile) == EOF)
4009 {
4010 if (set_last_error)
4011 pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
4012 status = MZ_FALSE;
4013 }
4014 }
4015 pState->m_pFile = NULL;
4016 }
4017 #endif /* #ifndef MINIZ_NO_STDIO */
4018  
4019 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4020 }
4021 0 pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
4022  
4023 0 return status;
4024 }
4025  
4026 0 mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
4027 {
4028 0 return mz_zip_reader_end_internal(pZip, MZ_TRUE);
4029 }
4030 0 mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags)
4031 {
4032 0 ▶ if ((!pZip) || (!pZip->m_pRead))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pRead)) 0 0 0
4033 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4034  
4035 0 ▶ if (!mz_zip_reader_init_internal(pZip, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_init_internal(pZip, flags)) 0 0 0
4036 0 return MZ_FALSE;
4037  
4038 0 pZip->m_zip_type = MZ_ZIP_TYPE_USER;
4039 0 pZip->m_archive_size = size;
4040  
4041 0 ▶ if (!mz_zip_reader_read_central_dir(pZip, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_read_central_dir(pZip, flags)) 0 0 0
4042 {
4043 0 mz_zip_reader_end_internal(pZip, MZ_FALSE);
4044 0 return MZ_FALSE;
4045 }
4046  
4047 0 return MZ_TRUE;
4048 }
4049  
4050 0 static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
4051 {
4052 0 mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
4053 0 ▶ size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);
Branch: 1 branch
BranchTrueFalseTotal
size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n); 0 0 0
4054 0 memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);
4055 0 return s;
4056 }
4057  
4058 0 mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
4059 {
4060 0 ▶ if (!pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (!pMem) 0 0 0
4061 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4062  
4063 0 ▶ if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
4064 0 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
4065  
4066 0 ▶ if (!mz_zip_reader_init_internal(pZip, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_init_internal(pZip, flags)) 0 0 0
4067 0 return MZ_FALSE;
4068  
4069 0 pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;
4070 0 pZip->m_archive_size = size;
4071 0 pZip->m_pRead = mz_zip_mem_read_func;
4072 0 pZip->m_pIO_opaque = pZip;
4073 0 pZip->m_pNeeds_keepalive = NULL;
4074  
4075 #ifdef __cplusplus
4076 pZip->m_pState->m_pMem = const_cast<void *>(pMem);
4077 #else
4078 0 pZip->m_pState->m_pMem = (void *)pMem;
4079 #endif
4080  
4081 0 pZip->m_pState->m_mem_size = size;
4082  
4083 0 ▶ if (!mz_zip_reader_read_central_dir(pZip, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_read_central_dir(pZip, flags)) 0 0 0
4084 {
4085 0 mz_zip_reader_end_internal(pZip, MZ_FALSE);
4086 0 return MZ_FALSE;
4087 }
4088  
4089 0 return MZ_TRUE;
4090 }
4091  
4092 #ifndef MINIZ_NO_STDIO
4093 static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
4094 {
4095 mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
4096 mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
4097  
4098 file_ofs += pZip->m_pState->m_file_archive_start_ofs;
4099  
4100 if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
4101 return 0;
4102  
4103 return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);
4104 }
4105  
4106 mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags)
4107 {
4108 return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);
4109 }
4110  
4111 mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)
4112 {
4113 mz_uint64 file_size;
4114 MZ_FILE *pFile;
4115  
4116 if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
4117 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4118  
4119 pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_READ_ALLOW_WRITING ) ? "r+b" : "rb");
4120 if (!pFile)
4121 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
4122  
4123 file_size = archive_size;
4124 if (!file_size)
4125 {
4126 if (MZ_FSEEK64(pFile, 0, SEEK_END))
4127 {
4128 MZ_FCLOSE(pFile);
4129 return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
4130 }
4131  
4132 file_size = MZ_FTELL64(pFile);
4133 }
4134  
4135 /* TODO: Better sanity check archive_size and the # of actual remaining bytes */
4136  
4137 if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
4138 {
4139 MZ_FCLOSE(pFile);
4140 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
4141 }
4142  
4143 if (!mz_zip_reader_init_internal(pZip, flags))
4144 {
4145 MZ_FCLOSE(pFile);
4146 return MZ_FALSE;
4147 }
4148  
4149 pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
4150 pZip->m_pRead = mz_zip_file_read_func;
4151 pZip->m_pIO_opaque = pZip;
4152 pZip->m_pState->m_pFile = pFile;
4153 pZip->m_archive_size = file_size;
4154 pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
4155  
4156 if (!mz_zip_reader_read_central_dir(pZip, flags))
4157 {
4158 mz_zip_reader_end_internal(pZip, MZ_FALSE);
4159 return MZ_FALSE;
4160 }
4161  
4162 return MZ_TRUE;
4163 }
4164  
4165 mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags)
4166 {
4167 mz_uint64 cur_file_ofs;
4168  
4169 if ((!pZip) || (!pFile))
4170 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
4171  
4172 cur_file_ofs = MZ_FTELL64(pFile);
4173  
4174 if (!archive_size)
4175 {
4176 if (MZ_FSEEK64(pFile, 0, SEEK_END))
4177 return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
4178  
4179 archive_size = MZ_FTELL64(pFile) - cur_file_ofs;
4180  
4181 if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
4182 return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
4183 }
4184  
4185 if (!mz_zip_reader_init_internal(pZip, flags))
4186 return MZ_FALSE;
4187  
4188 pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
4189 pZip->m_pRead = mz_zip_file_read_func;
4190  
4191 pZip->m_pIO_opaque = pZip;
4192 pZip->m_pState->m_pFile = pFile;
4193 pZip->m_archive_size = archive_size;
4194 pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;
4195  
4196 if (!mz_zip_reader_read_central_dir(pZip, flags))
4197 {
4198 mz_zip_reader_end_internal(pZip, MZ_FALSE);
4199 return MZ_FALSE;
4200 }
4201  
4202 return MZ_TRUE;
4203 }
4204  
4205 #endif /* #ifndef MINIZ_NO_STDIO */
4206  
4207 static MZ_FORCEINLINE const mz_uint8 *mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
4208 {
4209 0 ▶ if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files))
Branch: 15 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) 0 0 0
4210 0 return NULL;
4211 0 return &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
4212 }
4213  
4214 0 ▶ mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index)
Branch: 1 branch
BranchTrueFalseTotal
mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index) 0 0 0
4215 {
4216 mz_uint m_bit_flag;
4217 0 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4218 0 ▶ if (!p)
Branch: 1 branch
BranchTrueFalseTotal
if (!p) 0 0 0
4219 {
4220 mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4221 0 return MZ_FALSE;
4222 }
4223  
4224 0 m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
4225 0 return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0;
4226 }
4227  
4228 0 ▶ mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index)
Branch: 1 branch
BranchTrueFalseTotal
mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index) 0 0 0
4229 {
4230 mz_uint bit_flag;
4231 mz_uint method;
4232  
4233 0 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4234 0 ▶ if (!p)
Branch: 1 branch
BranchTrueFalseTotal
if (!p) 0 0 0
4235 {
4236 mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4237 0 return MZ_FALSE;
4238 }
4239  
4240 0 method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
4241 0 bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
4242  
4243 0 ▶ if ((method != 0) && (method != MZ_DEFLATED))
Branch: 2 branches
BranchTrueFalseTotal
if ((method != 0) && (method != MZ_DEFLATED)) 0 0 0
if ((method != 0) && (method != MZ_DEFLATED)) 0 0 0
4244 {
4245 mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
4246 0 return MZ_FALSE;
4247 }
4248  
4249 0 ▶ if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION))
Branch: 1 branch
BranchTrueFalseTotal
if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) 0 0 0
4250 {
4251 mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
4252 0 return MZ_FALSE;
4253 }
4254  
4255 0 ▶ if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)
Branch: 1 branch
BranchTrueFalseTotal
if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG) 0 0 0
4256 {
4257 mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
4258 0 return MZ_FALSE;
4259 }
4260  
4261 0 return MZ_TRUE;
4262 }
4263  
4264 0 ▶ mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index)
Branch: 1 branch
BranchTrueFalseTotal
mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index) 0 0 0
4265 {
4266 mz_uint filename_len, attribute_mapping_id, external_attr;
4267 0 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4268 0 ▶ if (!p)
Branch: 1 branch
BranchTrueFalseTotal
if (!p) 0 0 0
4269 {
4270 mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4271 0 return MZ_FALSE;
4272 }
4273  
4274 0 filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4275 0 ▶ if (filename_len)
Branch: 1 branch
BranchTrueFalseTotal
if (filename_len) 0 0 0
4276 {
4277 0 ▶ if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
Branch: 1 branch
BranchTrueFalseTotal
if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/') 0 0 0
4278 0 return MZ_TRUE;
4279 }
4280  
4281 /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
4282 /* Most/all zip writers (hopefully) set DOS file/directory attributes in the low 16-bits, so check for the DOS directory flag and ignore the source OS ID in the created by field. */
4283 /* FIXME: Remove this check? Is it necessary - we already check the filename. */
4284 0 attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
4285 (void)attribute_mapping_id;
4286  
4287 0 external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
4288 0 ▶ if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0) 0 0 0
4289 {
4290 0 return MZ_TRUE;
4291 }
4292  
4293 0 return MZ_FALSE;
4294 }
4295  
4296 0 static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, mz_uint file_index, const mz_uint8 *pCentral_dir_header, mz_zip_archive_file_stat *pStat, mz_bool *pFound_zip64_extra_data)
4297 {
4298 mz_uint n;
4299 0 const mz_uint8 *p = pCentral_dir_header;
4300  
4301 0 ▶ if (pFound_zip64_extra_data)
Branch: 1 branch
BranchTrueFalseTotal
if (pFound_zip64_extra_data) 0 0 0
4302 0 *pFound_zip64_extra_data = MZ_FALSE;
4303  
4304 0 ▶ if ((!p) || (!pStat))
Branch: 2 branches
BranchTrueFalseTotal
if ((!p) || (!pStat)) 0 0 0
if ((!p) || (!pStat)) 0 0 0
4305 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4306  
4307 /* Extract fields from the central directory record. */
4308 0 pStat->m_file_index = file_index;
4309 0 pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index);
4310 0 pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS);
4311 0 pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS);
4312 0 pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
4313 0 pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
4314 #ifndef MINIZ_NO_TIME
4315 0 pStat->m_time = mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS));
4316 #endif
4317 0 pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS);
4318 0 pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);
4319 0 pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);
4320 0 pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS);
4321 0 pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
4322 0 pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);
4323  
4324 /* Copy as much of the filename and comment as possible. */
4325 0 n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4326 0 n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1);
4327 0 memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
4328 0 pStat->m_filename[n] = '\0';
4329  
4330 0 n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS);
4331 0 n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1);
4332 0 pStat->m_comment_size = n;
4333 0 memcpy(pStat->m_comment, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), n);
4334 0 pStat->m_comment[n] = '\0';
4335  
4336 /* Set some flags for convienance */
4337 0 pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index);
4338 0 pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index);
4339 0 pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index);
4340  
4341 /* See if we need to read any zip64 extended information fields. */
4342 /* Confusingly, these zip64 fields can be present even on non-zip64 archives (Debian zip on a huge files from stdin piped to stdout creates them). */
4343 0 ▶ if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), pStat->m_local_header_ofs) == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), pStat->m_local_header_ofs) == MZ_UINT32_MAX) 0 0 0
4344 {
4345 /* Attempt to find zip64 extended information field in the entry's extra data */
4346 0 mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);
4347  
4348 0 ▶ if (extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining) 0 0 0
4349 {
4350 0 const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4351  
4352 do
4353 {
4354 mz_uint32 field_id;
4355 mz_uint32 field_data_size;
4356  
4357 0 ▶ if (extra_size_remaining < (sizeof(mz_uint16) * 2))
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) 0 0 0
4358 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4359  
4360 0 field_id = MZ_READ_LE16(pExtra_data);
4361 0 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
4362  
4363 0 ▶ if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) 0 0 0
4364 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4365  
4366 0 ▶ if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
Branch: 1 branch
BranchTrueFalseTotal
if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) 0 0 0
4367 {
4368 0 const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2;
4369 0 mz_uint32 field_data_remaining = field_data_size;
4370  
4371 0 ▶ if (pFound_zip64_extra_data)
Branch: 1 branch
BranchTrueFalseTotal
if (pFound_zip64_extra_data) 0 0 0
4372 0 *pFound_zip64_extra_data = MZ_TRUE;
4373  
4374 0 ▶ if (pStat->m_uncomp_size == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pStat->m_uncomp_size == MZ_UINT32_MAX) 0 0 0
4375 {
4376 0 ▶ if (field_data_remaining < sizeof(mz_uint64))
Branch: 1 branch
BranchTrueFalseTotal
if (field_data_remaining < sizeof(mz_uint64)) 0 0 0
4377 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4378  
4379 0 pStat->m_uncomp_size = MZ_READ_LE64(pField_data);
4380 0 pField_data += sizeof(mz_uint64);
4381 0 field_data_remaining -= sizeof(mz_uint64);
4382 }
4383  
4384 0 ▶ if (pStat->m_comp_size == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pStat->m_comp_size == MZ_UINT32_MAX) 0 0 0
4385 {
4386 0 ▶ if (field_data_remaining < sizeof(mz_uint64))
Branch: 1 branch
BranchTrueFalseTotal
if (field_data_remaining < sizeof(mz_uint64)) 0 0 0
4387 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4388  
4389 0 pStat->m_comp_size = MZ_READ_LE64(pField_data);
4390 0 pField_data += sizeof(mz_uint64);
4391 0 field_data_remaining -= sizeof(mz_uint64);
4392 }
4393  
4394 0 ▶ if (pStat->m_local_header_ofs == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pStat->m_local_header_ofs == MZ_UINT32_MAX) 0 0 0
4395 {
4396 0 ▶ if (field_data_remaining < sizeof(mz_uint64))
Branch: 1 branch
BranchTrueFalseTotal
if (field_data_remaining < sizeof(mz_uint64)) 0 0 0
4397 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4398  
4399 0 pStat->m_local_header_ofs = MZ_READ_LE64(pField_data);
4400 0 pField_data += sizeof(mz_uint64);
4401 0 field_data_remaining -= sizeof(mz_uint64);
4402 }
4403  
4404 0 break;
4405 }
4406  
4407 0 pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;
4408 0 extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;
4409 0 ▶ } while (extra_size_remaining);
Branch: 1 branch
BranchTrueFalseTotal
} while (extra_size_remaining); 0 0 0
4410 }
4411 }
4412  
4413 0 return MZ_TRUE;
4414 }
4415  
4416 static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
4417 {
4418 mz_uint i;
4419 0 ▶ if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE)
Branch: 2 branches
BranchTrueFalseTotal
if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE) 0 0 0
if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE) 0 0 0
4420 0 return 0 == memcmp(pA, pB, len);
4421 0 ▶ for (i = 0; i < len; ++i)
Branch: 2 branches
BranchTrueFalseTotal
for (i = 0; i < len; ++i) 0 0 0
for (i = 0; i < len; ++i) 0 0 0
4422 0 ▶ if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i]))
Branch: 10 branches
BranchTrueFalseTotal
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) 0 0 0
4423 0 return MZ_FALSE;
4424 0 return MZ_TRUE;
4425 }
4426  
4427 static MZ_FORCEINLINE int mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, const char *pR, mz_uint r_len)
4428 {
4429 0 const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;
4430 0 mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4431 0 mz_uint8 l = 0, r = 0;
4432 0 pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
4433 0 pE = pL + MZ_MIN(l_len, r_len);
4434 0 ▶ while (pL < pE)
Branch: 1 branch
BranchTrueFalseTotal
while (pL < pE) 0 0 0
4435 {
4436 0 ▶ if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))
Branch: 5 branches
BranchTrueFalseTotal
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) 0 0 0
4437 0 break;
4438 0 pL++;
4439 0 pR++;
4440 }
4441 0 ▶ return (pL == pE) ? (int)(l_len - r_len) : (l - r);
Branch: 1 branch
BranchTrueFalseTotal
return (pL == pE) ? (int)(l_len - r_len) : (l - r); 0 0 0
4442 }
4443  
4444 0 static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)
4445 {
4446 0 mz_zip_internal_state *pState = pZip->m_pState;
4447 0 const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;
4448 0 const mz_zip_array *pCentral_dir = &pState->m_central_dir;
4449 0 mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);
4450 0 const mz_uint32 size = pZip->m_total_files;
4451 0 const mz_uint filename_len = (mz_uint)strlen(pFilename);
4452  
4453 0 ▶ if (pIndex)
Branch: 1 branch
BranchTrueFalseTotal
if (pIndex) 0 0 0
4454 0 *pIndex = 0;
4455  
4456 0 ▶ if (size)
Branch: 1 branch
BranchTrueFalseTotal
if (size) 0 0 0
4457 {
4458 /* yes I could use uint32_t's, but then we would have to add some special case checks in the loop, argh, and */
4459 /* honestly the major expense here on 32-bit CPU's will still be the filename compare */
4460 0 mz_int64 l = 0, h = (mz_int64)size - 1;
4461  
4462 0 ▶ while (l <= h)
Branch: 1 branch
BranchTrueFalseTotal
while (l <= h) 0 0 0
4463 {
4464 0 mz_int64 m = l + ((h - l) >> 1);
4465 0 mz_uint32 file_index = pIndices[(mz_uint32)m];
4466  
4467 0 int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, file_index, pFilename, filename_len);
4468 0 ▶ if (!comp)
Branch: 1 branch
BranchTrueFalseTotal
if (!comp) 0 0 0
4469 {
4470 0 ▶ if (pIndex)
Branch: 1 branch
BranchTrueFalseTotal
if (pIndex) 0 0 0
4471 0 *pIndex = file_index;
4472 0 return MZ_TRUE;
4473 }
4474 0 ▶ else if (comp < 0)
Branch: 1 branch
BranchTrueFalseTotal
else if (comp < 0) 0 0 0
4475 0 l = m + 1;
4476 else
4477 0 h = m - 1;
4478 }
4479 }
4480  
4481 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
4482 }
4483  
4484 0 int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags)
4485 {
4486 mz_uint32 index;
4487 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index)) 0 0 0
4488 0 return -1;
4489 else
4490 0 return (int)index;
4491 }
4492  
4493 0 mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)
4494 {
4495 mz_uint file_index;
4496 size_t name_len, comment_len;
4497  
4498 0 ▶ if (pIndex)
Branch: 1 branch
BranchTrueFalseTotal
if (pIndex) 0 0 0
4499 0 *pIndex = 0;
4500  
4501 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pName))
Branch: 3 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pName)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pName)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pName)) 0 0 0
4502 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4503  
4504 /* See if we can use a binary search */
4505 0 ▶ if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) &&
Branch: 1 branch
BranchTrueFalseTotal
if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) && 0 0 0
4506 0 ▶ (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
Branch: 1 branch
BranchTrueFalseTotal
(pZip->m_zip_mode == MZ_ZIP_MODE_READING) && 0 0 0
4507 0 ▶ ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size))
Branch: 3 branches
BranchTrueFalseTotal
((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) 0 0 0
((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) 0 0 0
((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) 0 0 0
4508 {
4509 0 return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
4510 }
4511  
4512 /* Locate the entry by scanning the entire central directory */
4513 0 name_len = strlen(pName);
4514 0 ▶ if (name_len > MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (name_len > MZ_UINT16_MAX) 0 0 0
4515 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4516  
4517 0 ▶ comment_len = pComment ? strlen(pComment) : 0;
Branch: 1 branch
BranchTrueFalseTotal
comment_len = pComment ? strlen(pComment) : 0; 0 0 0
4518 0 ▶ if (comment_len > MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (comment_len > MZ_UINT16_MAX) 0 0 0
4519 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4520  
4521 0 ▶ for (file_index = 0; file_index < pZip->m_total_files; file_index++)
Branch: 1 branch
BranchTrueFalseTotal
for (file_index = 0; file_index < pZip->m_total_files; file_index++) 0 0 0
4522 {
4523 0 const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index));
4524 0 mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4525 0 const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
4526 0 ▶ if (filename_len < name_len)
Branch: 1 branch
BranchTrueFalseTotal
if (filename_len < name_len) 0 0 0
4527 0 continue;
4528 0 ▶ if (comment_len)
Branch: 1 branch
BranchTrueFalseTotal
if (comment_len) 0 0 0
4529 {
4530 0 mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), file_comment_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS);
4531 0 const char *pFile_comment = pFilename + filename_len + file_extra_len;
4532 0 ▶ if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
Branch: 2 branches
BranchTrueFalseTotal
if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags))) 0 0 0
if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags))) 0 0 0
4533 0 continue;
4534 }
4535 0 ▶ if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
Branch: 2 branches
BranchTrueFalseTotal
if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) 0 0 0
if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) 0 0 0
4536 {
4537 0 int ofs = filename_len - 1;
4538 do
4539 {
4540 0 ▶ if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
Branch: 3 branches
BranchTrueFalseTotal
if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':')) 0 0 0
if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':')) 0 0 0
if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':')) 0 0 0
4541 break;
4542 0 ▶ } while (--ofs >= 0);
Branch: 1 branch
BranchTrueFalseTotal
} while (--ofs >= 0); 0 0 0
4543 0 ofs++;
4544 0 pFilename += ofs;
4545 0 filename_len -= ofs;
4546 }
4547 0 ▶ if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags)))
Branch: 2 branches
BranchTrueFalseTotal
if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags))) 0 0 0
if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags))) 0 0 0
4548 {
4549 0 ▶ if (pIndex)
Branch: 1 branch
BranchTrueFalseTotal
if (pIndex) 0 0 0
4550 0 *pIndex = file_index;
4551 0 return MZ_TRUE;
4552 }
4553 }
4554  
4555 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND);
4556 }
4557  
4558 0 static mz_bool mz_zip_reader_extract_to_mem_no_alloc1(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size, const mz_zip_archive_file_stat *st)
4559 {
4560 0 int status = TINFL_STATUS_DONE;
4561 0 mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail;
4562 mz_zip_archive_file_stat file_stat;
4563 void *pRead_buf;
4564 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
4565 0 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
4566 tinfl_decompressor inflator;
4567  
4568 0 ▶ if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead))
Branch: 7 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) 0 0 0
4569 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4570  
4571 0 ▶ if (st)
Branch: 1 branch
BranchTrueFalseTotal
if (st) 0 0 0
4572 {
4573 0 file_stat = *st;
4574 }
4575 0 ▶ else if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
Branch: 1 branch
BranchTrueFalseTotal
else if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) 0 0 0
4576 0 return MZ_FALSE;
4577  
4578 /* A directory or zero length file */
4579 0 ▶ if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) 0 0 0
if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) 0 0 0
4580 0 return MZ_TRUE;
4581  
4582 /* Encryption and patch files are not supported. */
4583 0 ▶ if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
Branch: 1 branch
BranchTrueFalseTotal
if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) 0 0 0
4584 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
4585  
4586 /* This function only supports decompressing stored and deflate. */
4587 0 ▶ if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
Branch: 3 branches
BranchTrueFalseTotal
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
4588 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
4589  
4590 /* Ensure supplied output buffer is large enough. */
4591 0 ▶ needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
Branch: 1 branch
BranchTrueFalseTotal
needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size; 0 0 0
4592 0 ▶ if (buf_size < needed_size)
Branch: 1 branch
BranchTrueFalseTotal
if (buf_size < needed_size) 0 0 0
4593 0 return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL);
4594  
4595 /* Read and parse the local directory entry. */
4596 0 cur_file_ofs = file_stat.m_local_header_ofs;
4597 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
4598 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
4599  
4600 0 ▶ if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) 0 0 0
4601 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4602  
4603 0 cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
4604 0 ▶ if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) 0 0 0
4605 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4606  
4607 0 ▶ if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
Branch: 2 branches
BranchTrueFalseTotal
if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) 0 0 0
if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) 0 0 0
4608 {
4609 /* The file is stored or the caller has requested the compressed data. */
4610 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size) 0 0 0
4611 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
4612  
4613 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4614 0 ▶ if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0) 0 0 0
4615 {
4616 0 ▶ if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
Branch: 1 branch
BranchTrueFalseTotal
if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) 0 0 0
4617 0 return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
4618 }
4619 #endif
4620  
4621 0 return MZ_TRUE;
4622 }
4623  
4624 /* Decompress the file either directly from memory or from a file input buffer. */
4625 0 tinfl_init(&inflator);
4626  
4627 0 ▶ if (pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_pMem) 0 0 0
4628 {
4629 /* Read directly from the archive in memory. */
4630 0 pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
4631 0 read_buf_size = read_buf_avail = file_stat.m_comp_size;
4632 0 comp_remaining = 0;
4633 }
4634 0 ▶ else if (pUser_read_buf)
Branch: 1 branch
BranchTrueFalseTotal
else if (pUser_read_buf) 0 0 0
4635 {
4636 /* Use a user provided read buffer. */
4637 0 ▶ if (!user_read_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (!user_read_buf_size) 0 0 0
4638 0 return MZ_FALSE;
4639 0 pRead_buf = (mz_uint8 *)pUser_read_buf;
4640 0 read_buf_size = user_read_buf_size;
4641 0 read_buf_avail = 0;
4642 0 comp_remaining = file_stat.m_comp_size;
4643 }
4644 else
4645 {
4646 /* Temporarily allocate a read buffer. */
4647 0 read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
4648 if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF))
4649 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
4650  
4651 0 ▶ if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size))) 0 0 0
4652 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
4653  
4654 0 read_buf_avail = 0;
4655 0 comp_remaining = file_stat.m_comp_size;
4656 }
4657  
4658 do
4659 {
4660 /* The size_t cast here should be OK because we've verified that the output buffer is >= file_stat.m_uncomp_size above */
4661 0 size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs);
4662 0 ▶ if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
Branch: 2 branches
BranchTrueFalseTotal
if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) 0 0 0
if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) 0 0 0
4663 {
4664 0 read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
4665 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) 0 0 0
4666 {
4667 0 ▶ status = TINFL_STATUS_FAILED;
Branch: 1 branch
BranchTrueFalseTotal
status = TINFL_STATUS_FAILED; 0 0 0
4668 mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
4669 0 break;
4670 }
4671 0 cur_file_ofs += read_buf_avail;
4672 0 comp_remaining -= read_buf_avail;
4673 0 read_buf_ofs = 0;
4674 }
4675 0 in_buf_size = (size_t)read_buf_avail;
4676 0 ▶ status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0));
Branch: 1 branch
BranchTrueFalseTotal
status = tinfl_decompress(&inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0)); 0 0 0
4677 0 read_buf_avail -= in_buf_size;
4678 0 read_buf_ofs += in_buf_size;
4679 0 out_buf_ofs += out_buf_size;
4680 0 ▶ } while (status == TINFL_STATUS_NEEDS_MORE_INPUT);
Branch: 1 branch
BranchTrueFalseTotal
} while (status == TINFL_STATUS_NEEDS_MORE_INPUT); 0 0 0
4681  
4682 0 ▶ if (status == TINFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (status == TINFL_STATUS_DONE) 0 0 0
4683 {
4684 /* Make sure the entire file was decompressed, and check its CRC. */
4685 0 ▶ if (out_buf_ofs != file_stat.m_uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (out_buf_ofs != file_stat.m_uncomp_size) 0 0 0
4686 {
4687 mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
4688 0 status = TINFL_STATUS_FAILED;
4689 }
4690 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4691 0 ▶ else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32)
Branch: 1 branch
BranchTrueFalseTotal
else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) 0 0 0
4692 {
4693 mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED);
4694 0 status = TINFL_STATUS_FAILED;
4695 }
4696 #endif
4697 }
4698  
4699 0 ▶ if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf)) 0 0 0
if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf)) 0 0 0
4700 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
4701  
4702 0 return status == TINFL_STATUS_DONE;
4703 }
4704  
4705 0 mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
4706 {
4707 0 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL);
4708 }
4709  
4710 0 mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size)
4711 {
4712 mz_uint32 file_index;
4713 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) 0 0 0
4714 0 return MZ_FALSE;
4715 0 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL);
4716 }
4717  
4718 0 mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags)
4719 {
4720 0 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, NULL, 0, NULL);
4721 }
4722  
4723 0 mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags)
4724 {
4725 0 return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
4726 }
4727  
4728 0 void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
4729 {
4730 mz_zip_archive_file_stat file_stat;
4731 mz_uint64 alloc_size;
4732 void *pBuf;
4733  
4734 0 ▶ if (pSize)
Branch: 1 branch
BranchTrueFalseTotal
if (pSize) 0 0 0
4735 0 *pSize = 0;
4736  
4737 0 ▶ if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) 0 0 0
4738 0 return NULL;
4739  
4740 0 ▶ alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
Branch: 1 branch
BranchTrueFalseTotal
alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size; 0 0 0
4741 if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
4742 {
4743 mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
4744 return NULL;
4745 }
4746  
4747 0 ▶ if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size))) 0 0 0
4748 {
4749 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
4750 0 return NULL;
4751 }
4752  
4753 0 ▶ if (!mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, (size_t)alloc_size, flags, NULL, 0, &file_stat))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, (size_t)alloc_size, flags, NULL, 0, &file_stat)) 0 0 0
4754 {
4755 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
4756 0 return NULL;
4757 }
4758  
4759 0 ▶ if (pSize)
Branch: 1 branch
BranchTrueFalseTotal
if (pSize) 0 0 0
4760 0 *pSize = (size_t)alloc_size;
4761 0 return pBuf;
4762 }
4763  
4764 0 void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags)
4765 {
4766 mz_uint32 file_index;
4767 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) 0 0 0
4768 {
4769 0 ▶ if (pSize)
Branch: 1 branch
BranchTrueFalseTotal
if (pSize) 0 0 0
4770 0 *pSize = 0;
4771 0 return MZ_FALSE;
4772 }
4773 0 return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
4774 }
4775  
4776 0 mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
4777 {
4778 0 int status = TINFL_STATUS_DONE;
4779 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4780 0 mz_uint file_crc32 = MZ_CRC32_INIT;
4781 #endif
4782 0 mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
4783 mz_zip_archive_file_stat file_stat;
4784 0 void *pRead_buf = NULL;
4785 0 void *pWrite_buf = NULL;
4786 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
4787 0 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
4788  
4789 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) 0 0 0
4790 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
4791  
4792 0 ▶ if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) 0 0 0
4793 0 return MZ_FALSE;
4794  
4795 /* A directory or zero length file */
4796 0 ▶ if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) 0 0 0
if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) 0 0 0
4797 0 return MZ_TRUE;
4798  
4799 /* Encryption and patch files are not supported. */
4800 0 ▶ if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
Branch: 1 branch
BranchTrueFalseTotal
if (file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) 0 0 0
4801 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
4802  
4803 /* This function only supports decompressing stored and deflate. */
4804 0 ▶ if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
Branch: 3 branches
BranchTrueFalseTotal
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
4805 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
4806  
4807 /* Read and do some minimal validation of the local directory entry (this doesn't crack the zip64 stuff, which we already have from the central dir) */
4808 0 cur_file_ofs = file_stat.m_local_header_ofs;
4809 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
4810 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
4811  
4812 0 ▶ if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) 0 0 0
4813 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4814  
4815 0 cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
4816 0 ▶ if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) 0 0 0
4817 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
4818  
4819 /* Decompress the file either directly from memory or from a file input buffer. */
4820 0 ▶ if (pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_pMem) 0 0 0
4821 {
4822 0 pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
4823 0 read_buf_size = read_buf_avail = file_stat.m_comp_size;
4824 0 comp_remaining = 0;
4825 }
4826 else
4827 {
4828 0 read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
4829 0 ▶ if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size))) 0 0 0
4830 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
4831  
4832 0 read_buf_avail = 0;
4833 0 comp_remaining = file_stat.m_comp_size;
4834 }
4835  
4836 0 ▶ if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
Branch: 2 branches
BranchTrueFalseTotal
if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) 0 0 0
if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) 0 0 0
4837 {
4838 /* The file is stored or the caller has requested the compressed data. */
4839 0 ▶ if (pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_pMem) 0 0 0
4840 {
4841 if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX))
4842 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
4843  
4844 0 ▶ if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size) 0 0 0
4845 {
4846 mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
4847 0 status = TINFL_STATUS_FAILED;
4848 }
4849 0 ▶ else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
Branch: 1 branch
BranchTrueFalseTotal
else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
4850 {
4851 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4852 0 file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
4853 #endif
4854 }
4855  
4856 0 cur_file_ofs += file_stat.m_comp_size;
4857 0 out_buf_ofs += file_stat.m_comp_size;
4858 0 comp_remaining = 0;
4859 }
4860 else
4861 {
4862 0 ▶ while (comp_remaining)
Branch: 1 branch
BranchTrueFalseTotal
while (comp_remaining) 0 0 0
4863 {
4864 0 read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
4865 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) 0 0 0
4866 {
4867 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
4868 0 status = TINFL_STATUS_FAILED;
4869 0 break;
4870 }
4871  
4872 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4873 0 ▶ if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
Branch: 1 branch
BranchTrueFalseTotal
if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
4874 {
4875 0 file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
4876 }
4877 #endif
4878  
4879 0 ▶ if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) 0 0 0
4880 {
4881 mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
4882 0 status = TINFL_STATUS_FAILED;
4883 0 break;
4884 }
4885  
4886 0 cur_file_ofs += read_buf_avail;
4887 0 out_buf_ofs += read_buf_avail;
4888 0 comp_remaining -= read_buf_avail;
4889 }
4890 }
4891 }
4892 else
4893 {
4894 tinfl_decompressor inflator;
4895 0 tinfl_init(&inflator);
4896  
4897 0 ▶ if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE))) 0 0 0
4898 {
4899 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
4900 0 status = TINFL_STATUS_FAILED;
4901 }
4902 else
4903 {
4904 do
4905 {
4906 0 mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
4907 0 size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
4908 0 ▶ if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
Branch: 2 branches
BranchTrueFalseTotal
if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) 0 0 0
if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) 0 0 0
4909 {
4910 0 read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
4911 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) 0 0 0
4912 {
4913 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
4914 0 status = TINFL_STATUS_FAILED;
4915 0 break;
4916 }
4917 0 cur_file_ofs += read_buf_avail;
4918 0 comp_remaining -= read_buf_avail;
4919 0 read_buf_ofs = 0;
4920 }
4921  
4922 0 in_buf_size = (size_t)read_buf_avail;
4923 0 ▶ status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
Branch: 1 branch
BranchTrueFalseTotal
status = tinfl_decompress(&inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0); 0 0 0
4924 0 read_buf_avail -= in_buf_size;
4925 0 read_buf_ofs += in_buf_size;
4926  
4927 0 ▶ if (out_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (out_buf_size) 0 0 0
4928 {
4929 0 ▶ if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size) 0 0 0
4930 {
4931 mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED);
4932 0 status = TINFL_STATUS_FAILED;
4933 0 break;
4934 }
4935  
4936 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4937 0 file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
4938 #endif
4939 0 ▶ if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size) 0 0 0
4940 {
4941 mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
4942 0 status = TINFL_STATUS_FAILED;
4943 0 break;
4944 }
4945 }
4946 0 ▶ } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
Branch: 2 branches
BranchTrueFalseTotal
} while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT)); 0 0 0
} while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT)); 0 0 0
4947 }
4948 }
4949  
4950 0 ▶ if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
Branch: 2 branches
BranchTrueFalseTotal
if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
4951 {
4952 /* Make sure the entire file was decompressed, and check its CRC. */
4953 0 ▶ if (out_buf_ofs != file_stat.m_uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (out_buf_ofs != file_stat.m_uncomp_size) 0 0 0
4954 {
4955 mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
4956 0 status = TINFL_STATUS_FAILED;
4957 }
4958 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4959 0 ▶ else if (file_crc32 != file_stat.m_crc32)
Branch: 1 branch
BranchTrueFalseTotal
else if (file_crc32 != file_stat.m_crc32) 0 0 0
4960 {
4961 mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED);
4962 0 status = TINFL_STATUS_FAILED;
4963 }
4964 #endif
4965 }
4966  
4967 0 ▶ if (!pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pState->m_pMem) 0 0 0
4968 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
4969  
4970 0 ▶ if (pWrite_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (pWrite_buf) 0 0 0
4971 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
4972  
4973 0 return status == TINFL_STATUS_DONE;
4974 }
4975  
4976 0 mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags)
4977 {
4978 mz_uint32 file_index;
4979 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) 0 0 0
4980 0 return MZ_FALSE;
4981  
4982 0 return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
4983 }
4984  
4985 0 mz_zip_reader_extract_iter_state *mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
4986 {
4987 mz_zip_reader_extract_iter_state *pState;
4988 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
4989 0 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
4990  
4991 /* Argument sanity check */
4992 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
4993 0 return NULL;
4994  
4995 /* Allocate an iterator status structure */
4996 0 pState = (mz_zip_reader_extract_iter_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state));
4997 0 ▶ if (!pState)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState) 0 0 0
4998 {
4999 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5000 0 return NULL;
5001 }
5002  
5003 /* Fetch file details */
5004 0 ▶ if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat)) 0 0 0
5005 {
5006 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5007 0 return NULL;
5008 }
5009  
5010 /* Encryption and patch files are not supported. */
5011 0 ▶ if (pState->file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG))
Branch: 1 branch
BranchTrueFalseTotal
if (pState->file_stat.m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) 0 0 0
5012 {
5013 mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
5014 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5015 0 return NULL;
5016 }
5017  
5018 /* This function only supports decompressing stored and deflate. */
5019 0 ▶ if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED))
Branch: 3 branches
BranchTrueFalseTotal
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED)) 0 0 0
5020 {
5021 mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
5022 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5023 0 return NULL;
5024 }
5025  
5026 /* Init state - save args */
5027 0 pState->pZip = pZip;
5028 0 pState->flags = flags;
5029  
5030 /* Init state - reset variables to defaults */
5031 0 pState->status = TINFL_STATUS_DONE;
5032 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5033 0 pState->file_crc32 = MZ_CRC32_INIT;
5034 #endif
5035 0 pState->read_buf_ofs = 0;
5036 0 pState->out_buf_ofs = 0;
5037 0 pState->pRead_buf = NULL;
5038 0 pState->pWrite_buf = NULL;
5039 0 pState->out_blk_remain = 0;
5040  
5041 /* Read and parse the local directory entry. */
5042 0 pState->cur_file_ofs = pState->file_stat.m_local_header_ofs;
5043 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
5044 {
5045 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
5046 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5047 0 return NULL;
5048 }
5049  
5050 0 ▶ if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) 0 0 0
5051 {
5052 mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5053 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5054 0 return NULL;
5055 }
5056  
5057 0 pState->cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
5058 0 ▶ if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size) 0 0 0
5059 {
5060 mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5061 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5062 0 return NULL;
5063 }
5064  
5065 /* Decompress the file either directly from memory or from a file input buffer. */
5066 0 ▶ if (pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_pMem) 0 0 0
5067 {
5068 0 pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs;
5069 0 pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size;
5070 0 pState->comp_remaining = pState->file_stat.m_comp_size;
5071 }
5072 else
5073 {
5074 0 ▶ if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
Branch: 2 branches
BranchTrueFalseTotal
if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) 0 0 0
if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) 0 0 0
5075 {
5076 /* Decompression required, therefore intermediate read buffer required */
5077 0 pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
5078 0 ▶ if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size))) 0 0 0
5079 {
5080 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5081 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5082 0 return NULL;
5083 }
5084 }
5085 else
5086 {
5087 /* Decompression not required - we will be reading directly into user buffer, no temp buf required */
5088 0 pState->read_buf_size = 0;
5089 }
5090 0 pState->read_buf_avail = 0;
5091 0 pState->comp_remaining = pState->file_stat.m_comp_size;
5092 }
5093  
5094 0 ▶ if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
Branch: 2 branches
BranchTrueFalseTotal
if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) 0 0 0
if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) 0 0 0
5095 {
5096 /* Decompression required, init decompressor */
5097 0 tinfl_init(&pState->inflator);
5098  
5099 /* Allocate write buffer */
5100 0 ▶ if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE))) 0 0 0
5101 {
5102 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5103 0 ▶ if (pState->pRead_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->pRead_buf) 0 0 0
5104 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf);
5105 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5106 0 return NULL;
5107 }
5108 }
5109  
5110 0 return pState;
5111 }
5112  
5113 0 mz_zip_reader_extract_iter_state *mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
5114 {
5115 mz_uint32 file_index;
5116  
5117 /* Locate file index by name */
5118 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) 0 0 0
5119 0 return NULL;
5120  
5121 /* Construct iterator */
5122 0 return mz_zip_reader_extract_iter_new(pZip, file_index, flags);
5123 }
5124  
5125 0 size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state *pState, void *pvBuf, size_t buf_size)
5126 {
5127 0 size_t copied_to_caller = 0;
5128  
5129 /* Argument sanity check */
5130 0 ▶ if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) 0 0 0
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) 0 0 0
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) 0 0 0
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) 0 0 0
5131 0 return 0;
5132  
5133 0 ▶ if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))
Branch: 2 branches
BranchTrueFalseTotal
if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)) 0 0 0
if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)) 0 0 0
5134 {
5135 /* The file is stored or the caller has requested the compressed data, calc amount to return. */
5136 0 copied_to_caller = (size_t)MZ_MIN(buf_size, pState->comp_remaining);
5137  
5138 /* Zip is in memory....or requires reading from a file? */
5139 0 ▶ if (pState->pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->pZip->m_pState->m_pMem) 0 0 0
5140 {
5141 /* Copy data to caller's buffer */
5142 0 memcpy(pvBuf, pState->pRead_buf, copied_to_caller);
5143 0 pState->pRead_buf = ((mz_uint8 *)pState->pRead_buf) + copied_to_caller;
5144 }
5145 else
5146 {
5147 /* Read directly into caller's buffer */
5148 0 ▶ if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller) 0 0 0
5149 {
5150 /* Failed to read all that was asked for, flag failure and alert user */
5151 0 ▶ mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); 0 0 0
5152 0 pState->status = TINFL_STATUS_FAILED;
5153 0 copied_to_caller = 0;
5154 }
5155 }
5156  
5157 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5158 /* Compute CRC if not returning compressed data only */
5159 0 ▶ if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
Branch: 1 branch
BranchTrueFalseTotal
if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
5160 0 pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller);
5161 #endif
5162  
5163 /* Advance offsets, dec counters */
5164 0 pState->cur_file_ofs += copied_to_caller;
5165 0 pState->out_buf_ofs += copied_to_caller;
5166 0 pState->comp_remaining -= copied_to_caller;
5167 }
5168 else
5169 {
5170 do
5171 {
5172 /* Calc ptr to write buffer - given current output pos and block size */
5173 0 mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
5174  
5175 /* Calc max output size - given current output pos and block size */
5176 0 size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
5177  
5178 0 ▶ if (!pState->out_blk_remain)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->out_blk_remain) 0 0 0
5179 {
5180 /* Read more data from file if none available (and reading from file) */
5181 0 ▶ if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem)) 0 0 0
if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem)) 0 0 0
5182 {
5183 /* Calc read size */
5184 0 pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining);
5185 0 ▶ if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pState->pRead_buf, (size_t)pState->read_buf_avail) != pState->read_buf_avail)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pState->pRead_buf, (size_t)pState->read_buf_avail) != pState->read_buf_avail) 0 0 0
5186 {
5187 0 ▶ mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); 0 0 0
5188 0 pState->status = TINFL_STATUS_FAILED;
5189 0 break;
5190 }
5191  
5192 /* Advance offsets, dec counters */
5193 0 pState->cur_file_ofs += pState->read_buf_avail;
5194 0 pState->comp_remaining -= pState->read_buf_avail;
5195 0 pState->read_buf_ofs = 0;
5196 }
5197  
5198 /* Perform decompression */
5199 0 in_buf_size = (size_t)pState->read_buf_avail;
5200 0 ▶ pState->status = tinfl_decompress(&pState->inflator, (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, &out_buf_size, pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0);
Branch: 1 branch
BranchTrueFalseTotal
pState->status = tinfl_decompress(&pState->inflator, (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, &out_buf_size, pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0); 0 0 0
5201 0 pState->read_buf_avail -= in_buf_size;
5202 0 pState->read_buf_ofs += in_buf_size;
5203  
5204 /* Update current output block size remaining */
5205 0 pState->out_blk_remain = out_buf_size;
5206 }
5207  
5208 0 ▶ if (pState->out_blk_remain)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->out_blk_remain) 0 0 0
5209 {
5210 /* Calc amount to return. */
5211 0 size_t to_copy = MZ_MIN((buf_size - copied_to_caller), pState->out_blk_remain);
5212  
5213 /* Copy data to caller's buffer */
5214 0 memcpy((mz_uint8 *)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy);
5215  
5216 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5217 /* Perform CRC */
5218 0 pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy);
5219 #endif
5220  
5221 /* Decrement data consumed from block */
5222 0 pState->out_blk_remain -= to_copy;
5223  
5224 /* Inc output offset, while performing sanity check */
5225 0 ▶ if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size) 0 0 0
5226 {
5227 0 ▶ mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); 0 0 0
5228 0 pState->status = TINFL_STATUS_FAILED;
5229 0 break;
5230 }
5231  
5232 /* Increment counter of data copied to caller */
5233 0 copied_to_caller += to_copy;
5234 }
5235 0 ▶ } while ((copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT)));
Branch: 3 branches
BranchTrueFalseTotal
} while ((copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT))); 0 0 0
} while ((copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT))); 0 0 0
} while ((copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT))); 0 0 0
5236 }
5237  
5238 /* Return how many bytes were copied into user buffer */
5239 0 return copied_to_caller;
5240 }
5241  
5242 0 mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state *pState)
5243 {
5244 int status;
5245  
5246 /* Argument sanity check */
5247 0 ▶ if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
Branch: 3 branches
BranchTrueFalseTotal
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState)) 0 0 0
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState)) 0 0 0
if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState)) 0 0 0
5248 0 return MZ_FALSE;
5249  
5250 /* Was decompression completed and requested? */
5251 0 ▶ if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
Branch: 2 branches
BranchTrueFalseTotal
if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
5252 {
5253 /* Make sure the entire file was decompressed, and check its CRC. */
5254 0 ▶ if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size) 0 0 0
5255 {
5256 0 ▶ mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); 0 0 0
5257 0 pState->status = TINFL_STATUS_FAILED;
5258 }
5259 #ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5260 0 ▶ else if (pState->file_crc32 != pState->file_stat.m_crc32)
Branch: 1 branch
BranchTrueFalseTotal
else if (pState->file_crc32 != pState->file_stat.m_crc32) 0 0 0
5261 {
5262 0 ▶ mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); 0 0 0
5263 0 pState->status = TINFL_STATUS_FAILED;
5264 }
5265 #endif
5266 }
5267  
5268 /* Free buffers */
5269 0 ▶ if (!pState->pZip->m_pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->pZip->m_pState->m_pMem) 0 0 0
5270 0 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
5271 0 ▶ if (pState->pWrite_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->pWrite_buf) 0 0 0
5272 0 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);
5273  
5274 /* Save status */
5275 0 status = pState->status;
5276  
5277 /* Free context */
5278 0 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);
5279  
5280 0 return status == TINFL_STATUS_DONE;
5281 }
5282  
5283 #ifndef MINIZ_NO_STDIO
5284 static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
5285 {
5286 (void)ofs;
5287  
5288 return MZ_FWRITE(pBuf, 1, n, (MZ_FILE *)pOpaque);
5289 }
5290  
5291 mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
5292 {
5293 mz_bool status;
5294 mz_zip_archive_file_stat file_stat;
5295 MZ_FILE *pFile;
5296  
5297 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
5298 return MZ_FALSE;
5299  
5300 if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
5301 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
5302  
5303 pFile = MZ_FOPEN(pDst_filename, "wb");
5304 if (!pFile)
5305 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
5306  
5307 status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
5308  
5309 if (MZ_FCLOSE(pFile) == EOF)
5310 {
5311 if (status)
5312 mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
5313  
5314 status = MZ_FALSE;
5315 }
5316  
5317 #if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
5318 if (status)
5319 mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
5320 #endif
5321  
5322 return status;
5323 }
5324  
5325 mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags)
5326 {
5327 mz_uint32 file_index;
5328 if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
5329 return MZ_FALSE;
5330  
5331 return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
5332 }
5333  
5334 mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags)
5335 {
5336 mz_zip_archive_file_stat file_stat;
5337  
5338 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
5339 return MZ_FALSE;
5340  
5341 if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
5342 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
5343  
5344 return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
5345 }
5346  
5347 mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags)
5348 {
5349 mz_uint32 file_index;
5350 if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
5351 return MZ_FALSE;
5352  
5353 return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags);
5354 }
5355 #endif /* #ifndef MINIZ_NO_STDIO */
5356  
5357 0 static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
5358 {
5359 0 mz_uint32 *p = (mz_uint32 *)pOpaque;
5360 (void)file_ofs;
5361 0 *p = (mz_uint32)mz_crc32(*p, (const mz_uint8 *)pBuf, n);
5362 0 return n;
5363 }
5364  
5365 0 mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
5366 {
5367 mz_zip_archive_file_stat file_stat;
5368 mz_zip_internal_state *pState;
5369 const mz_uint8 *pCentral_dir_header;
5370 0 mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
5371 0 mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
5372 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
5373 0 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
5374 0 mz_uint64 local_header_ofs = 0;
5375 mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
5376 mz_uint64 local_header_comp_size, local_header_uncomp_size;
5377 0 mz_uint32 uncomp_crc32 = MZ_CRC32_INIT;
5378 mz_bool has_data_descriptor;
5379 mz_uint32 local_header_bit_flags;
5380  
5381 mz_zip_array file_data_array;
5382 mz_zip_array_init(&file_data_array, 1);
5383  
5384 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
Branch: 5 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
5385 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5386  
5387 0 ▶ if (file_index > pZip->m_total_files)
Branch: 1 branch
BranchTrueFalseTotal
if (file_index > pZip->m_total_files) 0 0 0
5388 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5389  
5390 0 ▶ pState = pZip->m_pState;
Branch: 1 branch
BranchTrueFalseTotal
pState = pZip->m_pState; 0 0 0
5391  
5392 0 pCentral_dir_header = mz_zip_get_cdh(pZip, file_index);
5393  
5394 0 ▶ if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir)) 0 0 0
5395 0 return MZ_FALSE;
5396  
5397 /* A directory or zero length file */
5398 0 ▶ if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size)) 0 0 0
if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size)) 0 0 0
5399 0 return MZ_TRUE;
5400  
5401 /* Encryption and patch files are not supported. */
5402 0 ▶ if (file_stat.m_is_encrypted)
Branch: 1 branch
BranchTrueFalseTotal
if (file_stat.m_is_encrypted) 0 0 0
5403 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);
5404  
5405 /* This function only supports stored and deflate. */
5406 0 ▶ if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
Branch: 2 branches
BranchTrueFalseTotal
if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) 0 0 0
5407 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD);
5408  
5409 0 ▶ if (!file_stat.m_is_supported)
Branch: 1 branch
BranchTrueFalseTotal
if (!file_stat.m_is_supported) 0 0 0
5410 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE);
5411  
5412 /* Read and parse the local directory entry. */
5413 0 local_header_ofs = file_stat.m_local_header_ofs;
5414 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
5415 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
5416  
5417 0 ▶ if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) 0 0 0
5418 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5419  
5420 0 local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
5421 0 local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
5422 0 local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
5423 0 local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
5424 0 local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS);
5425 0 local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
5426 0 has_data_descriptor = (local_header_bit_flags & 8) != 0;
5427  
5428 0 ▶ if (local_header_filename_len != strlen(file_stat.m_filename))
Branch: 1 branch
BranchTrueFalseTotal
if (local_header_filename_len != strlen(file_stat.m_filename)) 0 0 0
5429 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5430  
5431 0 ▶ if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size) > pZip->m_archive_size)
Branch: 1 branch
BranchTrueFalseTotal
if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size) > pZip->m_archive_size) 0 0 0
5432 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5433  
5434 0 ▶ if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE)) 0 0 0
if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE)) 0 0 0
5435 {
5436 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5437 0 goto handle_failure;
5438 }
5439  
5440 0 ▶ if (local_header_filename_len)
Branch: 1 branch
BranchTrueFalseTotal
if (local_header_filename_len) 0 0 0
5441 {
5442 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, file_data_array.m_p, local_header_filename_len) != local_header_filename_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, file_data_array.m_p, local_header_filename_len) != local_header_filename_len) 0 0 0
5443 {
5444 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
5445 0 goto handle_failure;
5446 }
5447  
5448 /* I've seen 1 archive that had the same pathname, but used backslashes in the local dir and forward slashes in the central dir. Do we care about this? For now, this case will fail validation. */
5449 0 ▶ if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0)
Branch: 1 branch
BranchTrueFalseTotal
if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0) 0 0 0
5450 {
5451 mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
5452 0 goto handle_failure;
5453 }
5454 }
5455  
5456 0 ▶ if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
Branch: 3 branches
BranchTrueFalseTotal
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
5457 {
5458 0 mz_uint32 extra_size_remaining = local_header_extra_len;
5459 0 const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p;
5460  
5461 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len, file_data_array.m_p, local_header_extra_len) != local_header_extra_len) 0 0 0
5462 {
5463 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
5464 0 goto handle_failure;
5465 }
5466  
5467 do
5468 {
5469 mz_uint32 field_id, field_data_size, field_total_size;
5470  
5471 0 ▶ if (extra_size_remaining < (sizeof(mz_uint16) * 2))
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) 0 0 0
5472 {
5473 mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5474 0 goto handle_failure;
5475 }
5476  
5477 0 field_id = MZ_READ_LE16(pExtra_data);
5478 0 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
5479 0 field_total_size = field_data_size + sizeof(mz_uint16) * 2;
5480  
5481 0 ▶ if (field_total_size > extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if (field_total_size > extra_size_remaining) 0 0 0
5482 {
5483 mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5484 0 goto handle_failure;
5485 }
5486  
5487 0 ▶ if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
Branch: 1 branch
BranchTrueFalseTotal
if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) 0 0 0
5488 {
5489 0 const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
5490  
5491 0 ▶ if (field_data_size < sizeof(mz_uint64) * 2)
Branch: 1 branch
BranchTrueFalseTotal
if (field_data_size < sizeof(mz_uint64) * 2) 0 0 0
5492 {
5493 mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
5494 0 goto handle_failure;
5495 }
5496  
5497 0 local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
5498 0 local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64));
5499  
5500 0 found_zip64_ext_data_in_ldir = MZ_TRUE;
5501 0 break;
5502 }
5503  
5504 0 pExtra_data += field_total_size;
5505 0 extra_size_remaining -= field_total_size;
5506 0 ▶ } while (extra_size_remaining);
Branch: 1 branch
BranchTrueFalseTotal
} while (extra_size_remaining); 0 0 0
5507 }
5508  
5509 /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */
5510 /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */
5511 0 ▶ if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
Branch: 3 branches
BranchTrueFalseTotal
if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32)) 0 0 0
if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32)) 0 0 0
if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32)) 0 0 0
5512 0 {
5513 mz_uint8 descriptor_buf[32];
5514 mz_bool has_id;
5515 const mz_uint8 *pSrc;
5516 mz_uint32 file_crc32;
5517 0 mz_uint64 comp_size = 0, uncomp_size = 0;
5518  
5519 0 ▶ mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
Branch: 2 branches
BranchTrueFalseTotal
mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4; 0 0 0
mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4; 0 0 0
5520  
5521 0 ▶ if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf, sizeof(mz_uint32) * num_descriptor_uint32s) != (sizeof(mz_uint32) * num_descriptor_uint32s))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_len + local_header_extra_len + file_stat.m_comp_size, descriptor_buf, sizeof(mz_uint32) * num_descriptor_uint32s) != (sizeof(mz_uint32) * num_descriptor_uint32s)) 0 0 0
5522 {
5523 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
5524 0 goto handle_failure;
5525 }
5526  
5527 0 has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
5528 0 ▶ pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf;
Branch: 1 branch
BranchTrueFalseTotal
pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf; 0 0 0
5529  
5530 0 file_crc32 = MZ_READ_LE32(pSrc);
5531  
5532 0 ▶ if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
Branch: 2 branches
BranchTrueFalseTotal
if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) 0 0 0
if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) 0 0 0
5533 {
5534 0 comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32));
5535 0 uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64));
5536 }
5537 else
5538 {
5539 0 comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32));
5540 0 uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32));
5541 }
5542  
5543 0 ▶ if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
Branch: 3 branches
BranchTrueFalseTotal
if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size)) 0 0 0
if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size)) 0 0 0
if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size)) 0 0 0
5544 {
5545 mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
5546 0 goto handle_failure;
5547 }
5548 }
5549 else
5550 {
5551 0 ▶ if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size))
Branch: 3 branches
BranchTrueFalseTotal
if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size)) 0 0 0
if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size)) 0 0 0
if ((local_header_crc32 != file_stat.m_crc32) || (local_header_comp_size != file_stat.m_comp_size) || (local_header_uncomp_size != file_stat.m_uncomp_size)) 0 0 0
5552 {
5553 mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
5554 0 goto handle_failure;
5555 }
5556 }
5557  
5558 mz_zip_array_clear(pZip, &file_data_array);
5559  
5560 0 ▶ if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0) 0 0 0
5561 {
5562 0 ▶ if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0)) 0 0 0
5563 0 return MZ_FALSE;
5564  
5565 /* 1 more check to be sure, although the extract checks too. */
5566 0 ▶ if (uncomp_crc32 != file_stat.m_crc32)
Branch: 1 branch
BranchTrueFalseTotal
if (uncomp_crc32 != file_stat.m_crc32) 0 0 0
5567 {
5568 mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
5569 0 return MZ_FALSE;
5570 }
5571 }
5572  
5573 0 return MZ_TRUE;
5574  
5575 0 handle_failure:
5576 mz_zip_array_clear(pZip, &file_data_array);
5577 0 return MZ_FALSE;
5578 }
5579  
5580 0 mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
5581 {
5582 mz_zip_internal_state *pState;
5583 mz_uint32 i;
5584  
5585 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
Branch: 5 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) 0 0 0
5586 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5587  
5588 0 pState = pZip->m_pState;
5589  
5590 /* Basic sanity checks */
5591 0 ▶ if (!pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->m_zip64) 0 0 0
5592 {
5593 0 ▶ if (pZip->m_total_files > MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files > MZ_UINT16_MAX) 0 0 0
5594 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
5595  
5596 0 ▶ if (pZip->m_archive_size > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_archive_size > MZ_UINT32_MAX) 0 0 0
5597 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
5598 }
5599 else
5600 {
5601 0 ▶ if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) 0 0 0
5602 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
5603 }
5604  
5605 0 ▶ for (i = 0; i < pZip->m_total_files; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < pZip->m_total_files; i++) 0 0 0
5606 {
5607 0 ▶ if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags) 0 0 0
5608 {
5609 mz_uint32 found_index;
5610 mz_zip_archive_file_stat stat;
5611  
5612 0 ▶ if (!mz_zip_reader_file_stat(pZip, i, &stat))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_file_stat(pZip, i, &stat)) 0 0 0
5613 0 return MZ_FALSE;
5614  
5615 0 ▶ if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index)) 0 0 0
5616 0 return MZ_FALSE;
5617  
5618 /* This check can fail if there are duplicate filenames in the archive (which we don't check for when writing - that's up to the user) */
5619 0 ▶ if (found_index != i)
Branch: 1 branch
BranchTrueFalseTotal
if (found_index != i) 0 0 0
5620 0 return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED);
5621 }
5622  
5623 0 ▶ if (!mz_zip_validate_file(pZip, i, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_validate_file(pZip, i, flags)) 0 0 0
5624 0 return MZ_FALSE;
5625 }
5626  
5627 0 return MZ_TRUE;
5628 }
5629  
5630 0 mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr)
5631 {
5632 0 mz_bool success = MZ_TRUE;
5633 mz_zip_archive zip;
5634 0 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
5635  
5636 0 ▶ if ((!pMem) || (!size))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pMem) || (!size)) 0 0 0
if ((!pMem) || (!size)) 0 0 0
5637 {
5638 0 ▶ if (pErr)
Branch: 1 branch
BranchTrueFalseTotal
if (pErr) 0 0 0
5639 0 *pErr = MZ_ZIP_INVALID_PARAMETER;
5640 0 return MZ_FALSE;
5641 }
5642  
5643 0 mz_zip_zero_struct(&zip);
5644  
5645 0 ▶ if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_init_mem(&zip, pMem, size, flags)) 0 0 0
5646 {
5647 0 ▶ if (pErr)
Branch: 1 branch
BranchTrueFalseTotal
if (pErr) 0 0 0
5648 0 *pErr = zip.m_last_error;
5649 0 return MZ_FALSE;
5650 }
5651  
5652 0 ▶ if (!mz_zip_validate_archive(&zip, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_validate_archive(&zip, flags)) 0 0 0
5653 {
5654 0 actual_err = zip.m_last_error;
5655 0 success = MZ_FALSE;
5656 }
5657  
5658 0 ▶ if (!mz_zip_reader_end_internal(&zip, success))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_reader_end_internal(&zip, success)) 0 0 0
5659 {
5660 0 ▶ if (!actual_err)
Branch: 1 branch
BranchTrueFalseTotal
if (!actual_err) 0 0 0
5661 0 actual_err = zip.m_last_error;
5662 0 success = MZ_FALSE;
5663 }
5664  
5665 0 ▶ if (pErr)
Branch: 1 branch
BranchTrueFalseTotal
if (pErr) 0 0 0
5666 0 *pErr = actual_err;
5667  
5668 0 return success;
5669 }
5670  
5671 #ifndef MINIZ_NO_STDIO
5672 mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr)
5673 {
5674 mz_bool success = MZ_TRUE;
5675 mz_zip_archive zip;
5676 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
5677  
5678 if (!pFilename)
5679 {
5680 if (pErr)
5681 *pErr = MZ_ZIP_INVALID_PARAMETER;
5682 return MZ_FALSE;
5683 }
5684  
5685 mz_zip_zero_struct(&zip);
5686  
5687 if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
5688 {
5689 if (pErr)
5690 *pErr = zip.m_last_error;
5691 return MZ_FALSE;
5692 }
5693  
5694 if (!mz_zip_validate_archive(&zip, flags))
5695 {
5696 actual_err = zip.m_last_error;
5697 success = MZ_FALSE;
5698 }
5699  
5700 if (!mz_zip_reader_end_internal(&zip, success))
5701 {
5702 if (!actual_err)
5703 actual_err = zip.m_last_error;
5704 success = MZ_FALSE;
5705 }
5706  
5707 if (pErr)
5708 *pErr = actual_err;
5709  
5710 return success;
5711 }
5712 #endif /* #ifndef MINIZ_NO_STDIO */
5713  
5714 /* ------------------- .ZIP archive writing */
5715  
5716 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
5717  
5718 static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v)
5719 {
5720 0 p[0] = (mz_uint8)v;
5721 0 p[1] = (mz_uint8)(v >> 8);
5722 0 }
5723 static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v)
5724 {
5725 0 p[0] = (mz_uint8)v;
5726 0 p[1] = (mz_uint8)(v >> 8);
5727 0 p[2] = (mz_uint8)(v >> 16);
5728 0 p[3] = (mz_uint8)(v >> 24);
5729 0 }
5730 static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v)
5731 {
5732 0 mz_write_le32(p, (mz_uint32)v);
5733 0 mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32));
5734 0 }
5735  
5736 #define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v))
5737 #define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v))
5738 #define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v))
5739  
5740 0 static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
5741 {
5742 0 mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
5743 0 mz_zip_internal_state *pState = pZip->m_pState;
5744 0 mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size);
5745  
5746 0 ▶ if (!n)
Branch: 1 branch
BranchTrueFalseTotal
if (!n) 0 0 0
5747 0 return 0;
5748  
5749 /* An allocation this big is likely to just fail on 32-bit systems, so don't even go there. */
5750 if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF))
5751 {
5752 mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
5753 return 0;
5754 }
5755  
5756 0 ▶ if (new_size > pState->m_mem_capacity)
Branch: 1 branch
BranchTrueFalseTotal
if (new_size > pState->m_mem_capacity) 0 0 0
5757 {
5758 void *pNew_block;
5759 0 size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity);
5760  
5761 0 ▶ while (new_capacity < new_size)
Branch: 1 branch
BranchTrueFalseTotal
while (new_capacity < new_size) 0 0 0
5762 0 new_capacity *= 2;
5763  
5764 0 ▶ if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity))) 0 0 0
5765 {
5766 mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5767 0 return 0;
5768 }
5769  
5770 0 pState->m_pMem = pNew_block;
5771 0 pState->m_mem_capacity = new_capacity;
5772 }
5773 0 memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n);
5774 0 pState->m_mem_size = (size_t)new_size;
5775 0 return n;
5776 }
5777  
5778 0 static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
5779 {
5780 mz_zip_internal_state *pState;
5781 0 mz_bool status = MZ_TRUE;
5782  
5783 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)))
Branch: 6 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) 0 0 0
5784 {
5785 0 ▶ if (set_last_error)
Branch: 1 branch
BranchTrueFalseTotal
if (set_last_error) 0 0 0
5786 mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5787 0 return MZ_FALSE;
5788 }
5789  
5790 0 pState = pZip->m_pState;
5791 0 pZip->m_pState = NULL;
5792 0 mz_zip_array_clear(pZip, &pState->m_central_dir);
5793 0 mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);
5794 0 mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);
5795  
5796 #ifndef MINIZ_NO_STDIO
5797 if (pState->m_pFile)
5798 {
5799 if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
5800 {
5801 if (MZ_FCLOSE(pState->m_pFile) == EOF)
5802 {
5803 if (set_last_error)
5804 mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
5805 status = MZ_FALSE;
5806 }
5807 }
5808  
5809 pState->m_pFile = NULL;
5810 }
5811 #endif /* #ifndef MINIZ_NO_STDIO */
5812  
5813 0 ▶ if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem))
Branch: 2 branches
BranchTrueFalseTotal
if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) 0 0 0
if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) 0 0 0
5814 {
5815 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem);
5816 0 pState->m_pMem = NULL;
5817 }
5818  
5819 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5820 0 pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;
5821 0 return status;
5822 }
5823  
5824 0 mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
5825 {
5826 0 mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0;
5827  
5828 0 ▶ if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) 0 0 0
5829 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5830  
5831 0 ▶ if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
Branch: 1 branch
BranchTrueFalseTotal
if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) 0 0 0
5832 {
5833 0 ▶ if (!pZip->m_pRead)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pRead) 0 0 0
5834 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5835 }
5836  
5837 0 ▶ if (pZip->m_file_offset_alignment)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_file_offset_alignment) 0 0 0
5838 {
5839 /* Ensure user specified file offset alignment is a power of 2. */
5840 0 ▶ if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1)) 0 0 0
5841 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
5842 }
5843  
5844 0 ▶ if (!pZip->m_pAlloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pAlloc) 0 0 0
5845 0 pZip->m_pAlloc = miniz_def_alloc_func;
5846 0 ▶ if (!pZip->m_pFree)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pFree) 0 0 0
5847 0 pZip->m_pFree = miniz_def_free_func;
5848 0 ▶ if (!pZip->m_pRealloc)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pRealloc) 0 0 0
5849 0 pZip->m_pRealloc = miniz_def_realloc_func;
5850  
5851 0 pZip->m_archive_size = existing_size;
5852 0 pZip->m_central_directory_file_ofs = 0;
5853 0 pZip->m_total_files = 0;
5854  
5855 0 ▶ if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) 0 0 0
5856 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5857  
5858 0 memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
5859  
5860 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));
5861 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));
5862 0 MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));
5863  
5864 0 pZip->m_pState->m_zip64 = zip64;
5865 0 pZip->m_pState->m_zip64_has_extended_info_fields = zip64;
5866  
5867 0 pZip->m_zip_type = MZ_ZIP_TYPE_USER;
5868 0 pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
5869  
5870 0 return MZ_TRUE;
5871 }
5872  
5873 0 mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size)
5874 {
5875 0 return mz_zip_writer_init_v2(pZip, existing_size, 0);
5876 }
5877  
5878 0 mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags)
5879 {
5880 0 pZip->m_pWrite = mz_zip_heap_write_func;
5881 0 pZip->m_pNeeds_keepalive = NULL;
5882  
5883 0 ▶ if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
Branch: 1 branch
BranchTrueFalseTotal
if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) 0 0 0
5884 0 pZip->m_pRead = mz_zip_mem_read_func;
5885  
5886 0 pZip->m_pIO_opaque = pZip;
5887  
5888 0 ▶ if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) 0 0 0
5889 0 return MZ_FALSE;
5890  
5891 0 pZip->m_zip_type = MZ_ZIP_TYPE_HEAP;
5892  
5893 0 ▶ if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
Branch: 1 branch
BranchTrueFalseTotal
if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning))) 0 0 0
5894 {
5895 0 ▶ if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size))) 0 0 0
5896 {
5897 0 mz_zip_writer_end_internal(pZip, MZ_FALSE);
5898 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
5899 }
5900 0 pZip->m_pState->m_mem_capacity = initial_allocation_size;
5901 }
5902  
5903 0 return MZ_TRUE;
5904 }
5905  
5906 0 mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size)
5907 {
5908 0 return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0);
5909 }
5910  
5911 #ifndef MINIZ_NO_STDIO
5912 static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
5913 {
5914 mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;
5915 mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
5916  
5917 file_ofs += pZip->m_pState->m_file_archive_start_ofs;
5918  
5919 if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))
5920 {
5921 mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
5922 return 0;
5923 }
5924  
5925 return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile);
5926 }
5927  
5928 mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning)
5929 {
5930 return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0);
5931 }
5932  
5933 mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags)
5934 {
5935 MZ_FILE *pFile;
5936  
5937 pZip->m_pWrite = mz_zip_file_write_func;
5938 pZip->m_pNeeds_keepalive = NULL;
5939  
5940 if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
5941 pZip->m_pRead = mz_zip_file_read_func;
5942  
5943 pZip->m_pIO_opaque = pZip;
5944  
5945 if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
5946 return MZ_FALSE;
5947  
5948 if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
5949 {
5950 mz_zip_writer_end(pZip);
5951 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
5952 }
5953  
5954 pZip->m_pState->m_pFile = pFile;
5955 pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
5956  
5957 if (size_to_reserve_at_beginning)
5958 {
5959 mz_uint64 cur_ofs = 0;
5960 char buf[4096];
5961  
5962 MZ_CLEAR_ARR(buf);
5963  
5964 do
5965 {
5966 size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
5967 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
5968 {
5969 mz_zip_writer_end(pZip);
5970 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
5971 }
5972 cur_ofs += n;
5973 size_to_reserve_at_beginning -= n;
5974 } while (size_to_reserve_at_beginning);
5975 }
5976  
5977 return MZ_TRUE;
5978 }
5979  
5980 mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags)
5981 {
5982 pZip->m_pWrite = mz_zip_file_write_func;
5983 pZip->m_pNeeds_keepalive = NULL;
5984  
5985 if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING)
5986 pZip->m_pRead = mz_zip_file_read_func;
5987  
5988 pZip->m_pIO_opaque = pZip;
5989  
5990 if (!mz_zip_writer_init_v2(pZip, 0, flags))
5991 return MZ_FALSE;
5992  
5993 pZip->m_pState->m_pFile = pFile;
5994 pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);
5995 pZip->m_zip_type = MZ_ZIP_TYPE_CFILE;
5996  
5997 return MZ_TRUE;
5998 }
5999 #endif /* #ifndef MINIZ_NO_STDIO */
6000  
6001 0 mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
6002 {
6003 mz_zip_internal_state *pState;
6004  
6005 0 ▶ if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
Branch: 3 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) 0 0 0
6006 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6007  
6008 0 ▶ if (flags & MZ_ZIP_FLAG_WRITE_ZIP64)
Branch: 1 branch
BranchTrueFalseTotal
if (flags & MZ_ZIP_FLAG_WRITE_ZIP64) 0 0 0
6009 {
6010 /* We don't support converting a non-zip64 file to zip64 - this seems like more trouble than it's worth. (What about the existing 32-bit data descriptors that could follow the compressed data?) */
6011 0 ▶ if (!pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pState->m_zip64) 0 0 0
6012 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6013 }
6014  
6015 /* No sense in trying to write to an archive that's already at the support max size */
6016 0 ▶ if (pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_zip64) 0 0 0
6017 {
6018 0 ▶ if (pZip->m_total_files == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT32_MAX) 0 0 0
6019 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
6020 }
6021 else
6022 {
6023 0 ▶ if (pZip->m_total_files == MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT16_MAX) 0 0 0
6024 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
6025  
6026 0 ▶ if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX) 0 0 0
6027 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
6028 }
6029  
6030 0 pState = pZip->m_pState;
6031  
6032 0 ▶ if (pState->m_pFile)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_pFile) 0 0 0
6033 {
6034 #ifdef MINIZ_NO_STDIO
6035 (void)pFilename;
6036 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6037 #else
6038 if (pZip->m_pIO_opaque != pZip)
6039 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6040  
6041 if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE &&
6042 !(flags & MZ_ZIP_FLAG_READ_ALLOW_WRITING) )
6043 {
6044 if (!pFilename)
6045 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6046  
6047 /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */
6048 if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
6049 {
6050 /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */
6051 mz_zip_reader_end_internal(pZip, MZ_FALSE);
6052 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
6053 }
6054 }
6055  
6056 pZip->m_pWrite = mz_zip_file_write_func;
6057 pZip->m_pNeeds_keepalive = NULL;
6058 #endif /* #ifdef MINIZ_NO_STDIO */
6059 }
6060 0 ▶ else if (pState->m_pMem)
Branch: 1 branch
BranchTrueFalseTotal
else if (pState->m_pMem) 0 0 0
6061 {
6062 /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */
6063 0 ▶ if (pZip->m_pIO_opaque != pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pIO_opaque != pZip) 0 0 0
6064 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6065  
6066 0 pState->m_mem_capacity = pState->m_mem_size;
6067 0 pZip->m_pWrite = mz_zip_heap_write_func;
6068 0 pZip->m_pNeeds_keepalive = NULL;
6069 }
6070 /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */
6071 0 ▶ else if (!pZip->m_pWrite)
Branch: 1 branch
BranchTrueFalseTotal
else if (!pZip->m_pWrite) 0 0 0
6072 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6073  
6074 /* Start writing new files at the archive's current central directory location. */
6075 /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */
6076 0 pZip->m_archive_size = pZip->m_central_directory_file_ofs;
6077 0 pZip->m_central_directory_file_ofs = 0;
6078  
6079 /* Clear the sorted central dir offsets, they aren't useful or maintained now. */
6080 /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */
6081 /* TODO: We could easily maintain the sorted central directory offsets. */
6082 0 mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets);
6083  
6084 0 pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
6085  
6086 0 return MZ_TRUE;
6087 }
6088  
6089 0 mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename)
6090 {
6091 0 return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
6092 }
6093  
6094 /* TODO: pArchive_name is a terrible name here! */
6095 0 mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags)
6096 {
6097 0 return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
6098 }
6099  
6100 typedef struct
6101 {
6102 mz_zip_archive *m_pZip;
6103 mz_uint64 m_cur_archive_file_ofs;
6104 mz_uint64 m_comp_size;
6105 } mz_zip_writer_add_state;
6106  
6107 0 static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
6108 {
6109 0 mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser;
6110 0 ▶ if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len)
Branch: 1 branch
BranchTrueFalseTotal
if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len) 0 0 0
6111 0 return MZ_FALSE;
6112  
6113 0 pState->m_cur_archive_file_ofs += len;
6114 0 pState->m_comp_size += len;
6115 0 return MZ_TRUE;
6116 }
6117  
6118 #define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2)
6119 #define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3)
6120 0 static mz_uint32 mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, mz_uint64 *pComp_size, mz_uint64 *pLocal_header_ofs)
6121 {
6122 0 mz_uint8 *pDst = pBuf;
6123 0 mz_uint32 field_size = 0;
6124  
6125 MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
6126 0 MZ_WRITE_LE16(pDst + 2, 0);
6127 0 pDst += sizeof(mz_uint16) * 2;
6128  
6129 0 ▶ if (pUncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pUncomp_size) 0 0 0
6130 {
6131 0 MZ_WRITE_LE64(pDst, *pUncomp_size);
6132 0 pDst += sizeof(mz_uint64);
6133 0 field_size += sizeof(mz_uint64);
6134 }
6135  
6136 0 ▶ if (pComp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pComp_size) 0 0 0
6137 {
6138 0 MZ_WRITE_LE64(pDst, *pComp_size);
6139 0 pDst += sizeof(mz_uint64);
6140 0 field_size += sizeof(mz_uint64);
6141 }
6142  
6143 0 ▶ if (pLocal_header_ofs)
Branch: 1 branch
BranchTrueFalseTotal
if (pLocal_header_ofs) 0 0 0
6144 {
6145 0 MZ_WRITE_LE64(pDst, *pLocal_header_ofs);
6146 0 pDst += sizeof(mz_uint64);
6147 0 field_size += sizeof(mz_uint64);
6148 }
6149  
6150 0 MZ_WRITE_LE16(pBuf + 2, field_size);
6151  
6152 0 return (mz_uint32)(pDst - pBuf);
6153 }
6154  
6155 0 static mz_bool mz_zip_writer_create_local_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date)
6156 {
6157 (void)pZip;
6158 0 memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE);
6159 MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG);
6160 0 ▶ MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0);
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0); 0 0 0
6161 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags);
6162 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method);
6163 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time);
6164 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date);
6165 0 MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32);
6166 0 ▶ MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX)); 0 0 0
6167 0 ▶ MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX)); 0 0 0
6168 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size);
6169 0 MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size);
6170 0 return MZ_TRUE;
6171 }
6172  
6173 0 static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst,
6174 mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_size,
6175 mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
6176 mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
6177 mz_uint64 local_header_ofs, mz_uint32 ext_attributes)
6178 {
6179 (void)pZip;
6180 0 memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
6181 MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG);
6182 0 ▶ MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0);
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0); 0 0 0
6183 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags);
6184 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method);
6185 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time);
6186 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date);
6187 0 MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32);
6188 0 ▶ MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX)); 0 0 0
6189 0 ▶ MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX)); 0 0 0
6190 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size);
6191 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size);
6192 0 MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size);
6193 0 MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes);
6194 0 ▶ MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_MIN(local_header_ofs, MZ_UINT32_MAX));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_MIN(local_header_ofs, MZ_UINT32_MAX)); 0 0 0
6195 0 return MZ_TRUE;
6196 }
6197  
6198 0 static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size,
6199 const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_size,
6200 mz_uint64 uncomp_size, mz_uint64 comp_size, mz_uint32 uncomp_crc32,
6201 mz_uint16 method, mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date,
6202 mz_uint64 local_header_ofs, mz_uint32 ext_attributes,
6203 const char *user_extra_data, mz_uint user_extra_data_len)
6204 {
6205 0 mz_zip_internal_state *pState = pZip->m_pState;
6206 0 mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size;
6207 0 size_t orig_central_dir_size = pState->m_central_dir.m_size;
6208 mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
6209  
6210 0 ▶ if (!pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_pState->m_zip64) 0 0 0
6211 {
6212 0 ▶ if (local_header_ofs > 0xFFFFFFFF)
Branch: 1 branch
BranchTrueFalseTotal
if (local_header_ofs > 0xFFFFFFFF) 0 0 0
6213 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
6214 }
6215  
6216 /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
6217 0 ▶ if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + user_extra_data_len + comment_size) >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + user_extra_data_len + comment_size) >= MZ_UINT32_MAX) 0 0 0
6218 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
6219  
6220 0 ▶ if (!mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, (mz_uint16)(extra_size + user_extra_data_len), comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_create_central_dir_header(pZip, central_dir_header, filename_size, (mz_uint16)(extra_size + user_extra_data_len), comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_header_ofs, ext_attributes)) 0 0 0
6221 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6222  
6223 0 ▶ if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) ||
Branch: 2 branches
BranchTrueFalseTotal
if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) || 0 0 0
if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) || 0 0 0
6224 0 ▶ (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) ||
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) || 0 0 0
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) || 0 0 0
6225 0 ▶ (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) ||
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) || 0 0 0
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) || 0 0 0
6226 0 ▶ (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) ||
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) || 0 0 0
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) || 0 0 0
6227 0 ▶ (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) ||
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) || 0 0 0
(!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) || 0 0 0
6228 0 ▶ (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1)))
Branch: 2 branches
BranchTrueFalseTotal
(!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1))) 0 0 0
(!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &central_dir_ofs, 1))) 0 0 0
6229 {
6230 /* Try to resize the central directory array back into its original state. */
6231 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
6232 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6233 }
6234  
6235 0 return MZ_TRUE;
6236 }
6237  
6238 0 static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
6239 {
6240 /* Basic ZIP archive filename validity checks: Valid filenames cannot start with a forward slash, cannot contain a drive letter, and cannot use DOS-style backward slashes. */
6241 0 ▶ if (*pArchive_name == '/')
Branch: 1 branch
BranchTrueFalseTotal
if (*pArchive_name == '/') 0 0 0
6242 0 return MZ_FALSE;
6243  
6244 /* Making sure the name does not contain drive letters or DOS style backward slashes is the responsibility of the program using miniz*/
6245  
6246 0 return MZ_TRUE;
6247 }
6248  
6249 0 static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
6250 {
6251 mz_uint32 n;
6252 0 ▶ if (!pZip->m_file_offset_alignment)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip->m_file_offset_alignment) 0 0 0
6253 0 return 0;
6254 0 n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1));
6255 0 return (mz_uint)((pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1));
6256 }
6257  
6258 0 static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
6259 {
6260 char buf[4096];
6261 0 memset(buf, 0, MZ_MIN(sizeof(buf), n));
6262 0 ▶ while (n)
Branch: 1 branch
BranchTrueFalseTotal
while (n) 0 0 0
6263 {
6264 0 mz_uint32 s = MZ_MIN(sizeof(buf), n);
6265 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s) 0 0 0
6266 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6267  
6268 0 cur_file_ofs += s;
6269 0 n -= s;
6270 }
6271 0 return MZ_TRUE;
6272 }
6273  
6274 0 mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
6275 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32)
6276 {
6277 0 return mz_zip_writer_add_mem_ex_v2(pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0);
6278 }
6279  
6280 0 mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size,
6281 mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified,
6282 const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
6283 {
6284 0 mz_uint16 method = 0, dos_time = 0, dos_date = 0;
6285 0 mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
6286 0 mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
6287 size_t archive_name_size;
6288 mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
6289 0 tdefl_compressor *pComp = NULL;
6290 mz_bool store_data_uncompressed;
6291 mz_zip_internal_state *pState;
6292 0 mz_uint8 *pExtra_data = NULL;
6293 0 mz_uint32 extra_size = 0;
6294 mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
6295 0 mz_uint16 bit_flags = 0;
6296  
6297 0 ▶ if ((int)level_and_flags < 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((int)level_and_flags < 0) 0 0 0
6298 0 level_and_flags = MZ_DEFAULT_LEVEL;
6299  
6300 0 ▶ if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
Branch: 3 branches
BranchTrueFalseTotal
if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) 0 0 0
6301 0 bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
6302  
6303 0 ▶ if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
Branch: 1 branch
BranchTrueFalseTotal
if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) 0 0 0
6304 0 bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
6305  
6306 0 level = level_and_flags & 0xF;
6307 0 ▶ store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
Branch: 2 branches
BranchTrueFalseTotal
store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)); 0 0 0
store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)); 0 0 0
6308  
6309 0 ▶ if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
Branch: 9 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
6310 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6311  
6312 0 pState = pZip->m_pState;
6313  
6314 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
6315 {
6316 0 ▶ if (pZip->m_total_files == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT32_MAX) 0 0 0
6317 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
6318 }
6319 else
6320 {
6321 0 ▶ if (pZip->m_total_files == MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT16_MAX) 0 0 0
6322 {
6323 0 pState->m_zip64 = MZ_TRUE;
6324 /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
6325 }
6326 0 ▶ if (((mz_uint64)buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
Branch: 2 branches
BranchTrueFalseTotal
if (((mz_uint64)buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF)) 0 0 0
if (((mz_uint64)buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF)) 0 0 0
6327 {
6328 0 pState->m_zip64 = MZ_TRUE;
6329 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6330 }
6331 }
6332  
6333 0 ▶ if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size)) 0 0 0
if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size)) 0 0 0
6334 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6335  
6336 0 ▶ if (!mz_zip_writer_validate_archive_name(pArchive_name))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_validate_archive_name(pArchive_name)) 0 0 0
6337 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
6338  
6339 #ifndef MINIZ_NO_TIME
6340 0 ▶ if (last_modified != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (last_modified != NULL) 0 0 0
6341 {
6342 0 mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date);
6343 }
6344 else
6345 {
6346 MZ_TIME_T cur_time;
6347 0 time(&cur_time);
6348 0 mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
6349 }
6350 #else
6351 (void)last_modified;
6352 #endif /* #ifndef MINIZ_NO_TIME */
6353  
6354 0 ▶ if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
Branch: 1 branch
BranchTrueFalseTotal
if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
6355 {
6356 0 uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
6357 0 uncomp_size = buf_size;
6358 0 ▶ if (uncomp_size <= 3)
Branch: 1 branch
BranchTrueFalseTotal
if (uncomp_size <= 3) 0 0 0
6359 {
6360 0 level = 0;
6361 0 store_data_uncompressed = MZ_TRUE;
6362 }
6363 }
6364  
6365 0 archive_name_size = strlen(pArchive_name);
6366 0 ▶ if (archive_name_size > MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (archive_name_size > MZ_UINT16_MAX) 0 0 0
6367 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
6368  
6369 0 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
6370  
6371 /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
6372 0 ▶ if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX) 0 0 0
6373 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
6374  
6375 0 ▶ if (!pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->m_zip64) 0 0 0
6376 {
6377 /* Bail early if the archive would obviously become too large */
6378 0 if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
6379 0 ▶ pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
Branch: 1 branch
BranchTrueFalseTotal
pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF) 0 0 0
6380 {
6381 0 pState->m_zip64 = MZ_TRUE;
6382 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6383 }
6384 }
6385  
6386 0 ▶ if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
Branch: 2 branches
BranchTrueFalseTotal
if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/')) 0 0 0
if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/')) 0 0 0
6387 {
6388 /* Set DOS Subdirectory attribute bit. */
6389 0 ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
6390  
6391 /* Subdirectories cannot contain data. */
6392 0 ▶ if ((buf_size) || (uncomp_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((buf_size) || (uncomp_size)) 0 0 0
if ((buf_size) || (uncomp_size)) 0 0 0
6393 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6394 }
6395  
6396 /* Try to do any allocations before writing to the archive, so if an allocation fails the file remains unmodified. (A good idea if we're doing an in-place modification.) */
6397 0 ▶ if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1)))
Branch: 5 branches
BranchTrueFalseTotal
if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) 0 0 0
if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) 0 0 0
if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) 0 0 0
if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) 0 0 0
if ((!mz_zip_array_ensure_room(pZip, &pState->m_central_dir, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) 0 0 0
6398 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6399  
6400 0 ▶ if ((!store_data_uncompressed) && (buf_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((!store_data_uncompressed) && (buf_size)) 0 0 0
if ((!store_data_uncompressed) && (buf_size)) 0 0 0
6401 {
6402 0 ▶ if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor)))) 0 0 0
6403 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6404 }
6405  
6406 0 ▶ if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes)) 0 0 0
6407 {
6408 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6409 0 return MZ_FALSE;
6410 }
6411  
6412 0 local_dir_header_ofs += num_alignment_padding_bytes;
6413 0 if (pZip->m_file_offset_alignment)
6414 {
6415 MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
6416 }
6417 0 cur_archive_file_ofs += num_alignment_padding_bytes;
6418  
6419 0 MZ_CLEAR_ARR(local_dir_header);
6420  
6421 0 ▶ if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
Branch: 2 branches
BranchTrueFalseTotal
if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) 0 0 0
6422 {
6423 0 method = MZ_DEFLATED;
6424 }
6425  
6426 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
6427 {
6428 0 ▶ if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
Branch: 2 branches
BranchTrueFalseTotal
if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) 0 0 0
if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) 0 0 0
6429 {
6430 0 pExtra_data = extra_data;
6431 0 ▶ extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
Branch: 1 branch
BranchTrueFalseTotal
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
6432 0 ▶ (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 2 branches
BranchTrueFalseTotal
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6433 }
6434  
6435 0 ▶ if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, bit_flags, dos_time, dos_date))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, bit_flags, dos_time, dos_date)) 0 0 0
6436 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6437  
6438 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) 0 0 0
6439 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6440  
6441 0 cur_archive_file_ofs += sizeof(local_dir_header);
6442  
6443 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) 0 0 0
6444 {
6445 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6446 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6447 }
6448 0 cur_archive_file_ofs += archive_name_size;
6449  
6450 0 ▶ if (pExtra_data != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data != NULL) 0 0 0
6451 {
6452 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size) 0 0 0
6453 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6454  
6455 0 cur_archive_file_ofs += extra_size;
6456 }
6457 }
6458 else
6459 {
6460 0 ▶ if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
Branch: 2 branches
BranchTrueFalseTotal
if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) 0 0 0
if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) 0 0 0
6461 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
6462 0 ▶ if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, bit_flags, dos_time, dos_date)) 0 0 0
6463 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6464  
6465 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) 0 0 0
6466 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6467  
6468 0 cur_archive_file_ofs += sizeof(local_dir_header);
6469  
6470 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) 0 0 0
6471 {
6472 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6473 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6474 }
6475 0 cur_archive_file_ofs += archive_name_size;
6476 }
6477  
6478 0 ▶ if (user_extra_data_len > 0)
Branch: 1 branch
BranchTrueFalseTotal
if (user_extra_data_len > 0) 0 0 0
6479 {
6480 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len) 0 0 0
6481 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6482  
6483 0 cur_archive_file_ofs += user_extra_data_len;
6484 }
6485  
6486 0 ▶ if (store_data_uncompressed)
Branch: 1 branch
BranchTrueFalseTotal
if (store_data_uncompressed) 0 0 0
6487 {
6488 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size) 0 0 0
6489 {
6490 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6491 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6492 }
6493  
6494 0 cur_archive_file_ofs += buf_size;
6495 0 comp_size = buf_size;
6496 }
6497 0 ▶ else if (buf_size)
Branch: 1 branch
BranchTrueFalseTotal
else if (buf_size) 0 0 0
6498 {
6499 mz_zip_writer_add_state state;
6500  
6501 0 state.m_pZip = pZip;
6502 0 state.m_cur_archive_file_ofs = cur_archive_file_ofs;
6503 0 state.m_comp_size = 0;
6504  
6505 0 if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) ||
6506 0 (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
6507 {
6508 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6509 0 return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
6510 }
6511  
6512 0 comp_size = state.m_comp_size;
6513 0 cur_archive_file_ofs = state.m_cur_archive_file_ofs;
6514 }
6515  
6516 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6517 0 pComp = NULL;
6518  
6519 0 ▶ if (uncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (uncomp_size) 0 0 0
6520 {
6521 mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
6522 0 mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
6523  
6524 MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR);
6525  
6526 MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
6527 0 MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
6528 0 ▶ if (pExtra_data == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data == NULL) 0 0 0
6529 {
6530 0 ▶ if (comp_size > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (comp_size > MZ_UINT32_MAX) 0 0 0
6531 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
6532  
6533 0 MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
6534 0 MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
6535 }
6536 else
6537 {
6538 0 MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
6539 0 MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
6540 0 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
6541 }
6542  
6543 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size) 0 0 0
6544 0 return MZ_FALSE;
6545  
6546 0 cur_archive_file_ofs += local_dir_footer_size;
6547 }
6548  
6549 0 ▶ if (pExtra_data != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data != NULL) 0 0 0
6550 {
6551 0 ▶ extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
Branch: 1 branch
BranchTrueFalseTotal
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
6552 0 ▶ (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 2 branches
BranchTrueFalseTotal
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6553 }
6554  
6555 0 ▶ if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment,
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment, 0 0 0
6556 comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
6557 user_extra_data_central, user_extra_data_central_len))
6558 0 return MZ_FALSE;
6559  
6560 0 pZip->m_total_files++;
6561 0 pZip->m_archive_size = cur_archive_file_ofs;
6562  
6563 0 return MZ_TRUE;
6564 }
6565  
6566 0 mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void *callback_opaque, mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
6567 const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
6568 {
6569 mz_uint16 gen_flags;
6570 0 mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
6571 0 mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
6572 0 mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = 0, comp_size = 0;
6573 size_t archive_name_size;
6574 mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
6575 0 mz_uint8 *pExtra_data = NULL;
6576 0 mz_uint32 extra_size = 0;
6577 mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE];
6578 mz_zip_internal_state *pState;
6579 0 mz_uint64 file_ofs = 0, cur_archive_header_file_ofs;
6580  
6581 0 ▶ if ((int)level_and_flags < 0)
Branch: 1 branch
BranchTrueFalseTotal
if ((int)level_and_flags < 0) 0 0 0
6582 0 level_and_flags = MZ_DEFAULT_LEVEL;
6583 0 level = level_and_flags & 0xF;
6584  
6585 0 ▶ gen_flags = (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) ? 0 : MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
Branch: 1 branch
BranchTrueFalseTotal
gen_flags = (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) ? 0 : MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; 0 0 0
6586  
6587 0 ▶ if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
Branch: 1 branch
BranchTrueFalseTotal
if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) 0 0 0
6588 0 gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8;
6589  
6590 /* Sanity checks */
6591 0 ▶ if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
Branch: 7 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) 0 0 0
6592 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6593  
6594 0 pState = pZip->m_pState;
6595  
6596 0 ▶ if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX)) 0 0 0
if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX)) 0 0 0
6597 {
6598 /* Source file is too large for non-zip64 */
6599 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6600 0 pState->m_zip64 = MZ_TRUE;
6601 }
6602  
6603 /* We could support this, but why? */
6604 0 ▶ if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
Branch: 1 branch
BranchTrueFalseTotal
if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA) 0 0 0
6605 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
6606  
6607 0 ▶ if (!mz_zip_writer_validate_archive_name(pArchive_name))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_validate_archive_name(pArchive_name)) 0 0 0
6608 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
6609  
6610 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
6611 {
6612 0 ▶ if (pZip->m_total_files == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT32_MAX) 0 0 0
6613 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
6614 }
6615 else
6616 {
6617 0 ▶ if (pZip->m_total_files == MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT16_MAX) 0 0 0
6618 {
6619 0 pState->m_zip64 = MZ_TRUE;
6620 /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
6621 }
6622 }
6623  
6624 0 archive_name_size = strlen(pArchive_name);
6625 0 ▶ if (archive_name_size > MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (archive_name_size > MZ_UINT16_MAX) 0 0 0
6626 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME);
6627  
6628 0 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
6629  
6630 /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
6631 0 ▶ if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (((mz_uint64)pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX) 0 0 0
6632 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
6633  
6634 0 ▶ if (!pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->m_zip64) 0 0 0
6635 {
6636 /* Bail early if the archive would obviously become too large */
6637 0 ▶ if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024 + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
Branch: 1 branch
BranchTrueFalseTotal
if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024 + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF) 0 0 0
6638 {
6639 0 pState->m_zip64 = MZ_TRUE;
6640 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6641 }
6642 }
6643  
6644 #ifndef MINIZ_NO_TIME
6645 0 ▶ if (pFile_time)
Branch: 1 branch
BranchTrueFalseTotal
if (pFile_time) 0 0 0
6646 {
6647 0 mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
6648 }
6649 #else
6650 (void)pFile_time;
6651 #endif
6652  
6653 0 ▶ if (max_size <= 3)
Branch: 1 branch
BranchTrueFalseTotal
if (max_size <= 3) 0 0 0
6654 0 level = 0;
6655  
6656 0 ▶ if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes)) 0 0 0
6657 {
6658 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6659 }
6660  
6661 0 cur_archive_file_ofs += num_alignment_padding_bytes;
6662 0 local_dir_header_ofs = cur_archive_file_ofs;
6663  
6664 0 if (pZip->m_file_offset_alignment)
6665 {
6666 MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
6667 }
6668  
6669 0 ▶ if (max_size && level)
Branch: 2 branches
BranchTrueFalseTotal
if (max_size && level) 0 0 0
if (max_size && level) 0 0 0
6670 {
6671 0 method = MZ_DEFLATED;
6672 }
6673  
6674 0 MZ_CLEAR_ARR(local_dir_header);
6675 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
6676 {
6677 0 ▶ if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
Branch: 2 branches
BranchTrueFalseTotal
if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) 0 0 0
if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) 0 0 0
6678 {
6679 0 pExtra_data = extra_data;
6680 0 ▶ if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) 0 0 0
6681 0 ▶ extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
Branch: 2 branches
BranchTrueFalseTotal
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
6682 (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL,
6683 0 ▶ (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 1 branch
BranchTrueFalseTotal
(local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6684 else
6685 0 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, NULL,
6686 NULL,
6687 0 ▶ (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 1 branch
BranchTrueFalseTotal
(local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6688 }
6689  
6690 0 ▶ if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, gen_flags, dos_time, dos_date))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, gen_flags, dos_time, dos_date)) 0 0 0
6691 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6692  
6693 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) 0 0 0
6694 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6695  
6696 0 cur_archive_file_ofs += sizeof(local_dir_header);
6697  
6698 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) 0 0 0
6699 {
6700 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6701 }
6702  
6703 0 cur_archive_file_ofs += archive_name_size;
6704  
6705 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size) 0 0 0
6706 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6707  
6708 0 cur_archive_file_ofs += extra_size;
6709 }
6710 else
6711 {
6712 0 ▶ if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
Branch: 2 branches
BranchTrueFalseTotal
if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) 0 0 0
if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) 0 0 0
6713 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
6714 0 ▶ if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, (mz_uint16)archive_name_size, (mz_uint16)user_extra_data_len, 0, 0, 0, method, gen_flags, dos_time, dos_date)) 0 0 0
6715 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6716  
6717 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) 0 0 0
6718 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6719  
6720 0 cur_archive_file_ofs += sizeof(local_dir_header);
6721  
6722 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) 0 0 0
6723 {
6724 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6725 }
6726  
6727 0 cur_archive_file_ofs += archive_name_size;
6728 }
6729  
6730 0 ▶ if (user_extra_data_len > 0)
Branch: 1 branch
BranchTrueFalseTotal
if (user_extra_data_len > 0) 0 0 0
6731 {
6732 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len) 0 0 0
6733 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6734  
6735 0 cur_archive_file_ofs += user_extra_data_len;
6736 }
6737  
6738 0 ▶ if (max_size)
Branch: 1 branch
BranchTrueFalseTotal
if (max_size) 0 0 0
6739 {
6740 0 void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
6741 0 ▶ if (!pRead_buf)
Branch: 1 branch
BranchTrueFalseTotal
if (!pRead_buf) 0 0 0
6742 {
6743 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6744 }
6745  
6746 0 ▶ if (!level)
Branch: 1 branch
BranchTrueFalseTotal
if (!level) 0 0 0
6747 {
6748 while (1)
6749 0 {
6750 0 size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
6751 0 ▶ if (n == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (n == 0) 0 0 0
6752 0 break;
6753  
6754 0 ▶ if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) 0 0 0
if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) 0 0 0
6755 {
6756 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6757 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
6758 }
6759 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n) 0 0 0
6760 {
6761 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6762 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6763 }
6764 0 file_ofs += n;
6765 0 uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
6766 0 cur_archive_file_ofs += n;
6767 }
6768 0 uncomp_size = file_ofs;
6769 0 comp_size = uncomp_size;
6770 }
6771 else
6772 {
6773 0 mz_bool result = MZ_FALSE;
6774 mz_zip_writer_add_state state;
6775 0 tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
6776 0 ▶ if (!pComp)
Branch: 1 branch
BranchTrueFalseTotal
if (!pComp) 0 0 0
6777 {
6778 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6779 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6780 }
6781  
6782 0 state.m_pZip = pZip;
6783 0 state.m_cur_archive_file_ofs = cur_archive_file_ofs;
6784 0 state.m_comp_size = 0;
6785  
6786 0 ▶ if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY)
Branch: 1 branch
BranchTrueFalseTotal
if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, tdefl_create_comp_flags_from_zip_params(level, -15, MZ_DEFAULT_STRATEGY)) != TDEFL_STATUS_OKAY) 0 0 0
6787 {
6788 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6789 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6790 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6791 }
6792  
6793 for (;;)
6794 0 {
6795 tdefl_status status;
6796 0 tdefl_flush flush = TDEFL_NO_FLUSH;
6797  
6798 0 size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
6799 0 ▶ if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
Branch: 2 branches
BranchTrueFalseTotal
if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) 0 0 0
if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) 0 0 0
6800 {
6801 mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
6802 0 break;
6803 }
6804  
6805 0 file_ofs += n;
6806 0 uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
6807  
6808 0 ▶ if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque))
Branch: 2 branches
BranchTrueFalseTotal
if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque)) 0 0 0
if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque)) 0 0 0
6809 0 flush = TDEFL_FULL_FLUSH;
6810  
6811 0 ▶ if (n == 0)
Branch: 1 branch
BranchTrueFalseTotal
if (n == 0) 0 0 0
6812 0 flush = TDEFL_FINISH;
6813  
6814 0 status = tdefl_compress_buffer(pComp, pRead_buf, n, flush);
6815 0 ▶ if (status == TDEFL_STATUS_DONE)
Branch: 1 branch
BranchTrueFalseTotal
if (status == TDEFL_STATUS_DONE) 0 0 0
6816 {
6817 0 result = MZ_TRUE;
6818 0 break;
6819 }
6820 0 ▶ else if (status != TDEFL_STATUS_OKAY)
Branch: 1 branch
BranchTrueFalseTotal
else if (status != TDEFL_STATUS_OKAY) 0 0 0
6821 {
6822 mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED);
6823 0 break;
6824 }
6825 }
6826  
6827 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6828  
6829 0 ▶ if (!result)
Branch: 1 branch
BranchTrueFalseTotal
if (!result) 0 0 0
6830 {
6831 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6832 0 return MZ_FALSE;
6833 }
6834  
6835 0 uncomp_size = file_ofs;
6836 0 comp_size = state.m_comp_size;
6837 0 cur_archive_file_ofs = state.m_cur_archive_file_ofs;
6838 }
6839  
6840 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6841 }
6842  
6843 0 ▶ if (!(level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE))
Branch: 1 branch
BranchTrueFalseTotal
if (!(level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)) 0 0 0
6844 {
6845 mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
6846 0 mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
6847  
6848 MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
6849 0 MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
6850 0 ▶ if (pExtra_data == NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data == NULL) 0 0 0
6851 {
6852 0 ▶ if (comp_size > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (comp_size > MZ_UINT32_MAX) 0 0 0
6853 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
6854  
6855 0 MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
6856 0 MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
6857 }
6858 else
6859 {
6860 0 MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
6861 0 MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
6862 0 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
6863 }
6864  
6865 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size) 0 0 0
6866 0 return MZ_FALSE;
6867  
6868 0 cur_archive_file_ofs += local_dir_footer_size;
6869 }
6870  
6871 0 ▶ if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) 0 0 0
6872 {
6873 0 ▶ if (pExtra_data != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data != NULL) 0 0 0
6874 {
6875 0 ▶ extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
Branch: 2 branches
BranchTrueFalseTotal
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
6876 0 ▶ (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 1 branch
BranchTrueFalseTotal
(max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6877 }
6878  
6879 0 ▶ if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header,
Branch: 3 branches
BranchTrueFalseTotal
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, 0 0 0
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, 0 0 0
if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header, 0 0 0
6880 0 (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len),
6881 (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size,
6882 (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : comp_size,
6883 uncomp_crc32, method, gen_flags, dos_time, dos_date))
6884 0 return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR);
6885  
6886 0 cur_archive_header_file_ofs = local_dir_header_ofs;
6887  
6888 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) 0 0 0
6889 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6890  
6891 0 ▶ if (pExtra_data != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data != NULL) 0 0 0
6892 {
6893 0 cur_archive_header_file_ofs += sizeof(local_dir_header);
6894  
6895 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, pArchive_name, archive_name_size) != archive_name_size) 0 0 0
6896 {
6897 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6898 }
6899  
6900 0 cur_archive_header_file_ofs += archive_name_size;
6901  
6902 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, extra_data, extra_size) != extra_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, extra_data, extra_size) != extra_size) 0 0 0
6903 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
6904  
6905 0 cur_archive_header_file_ofs += extra_size;
6906 }
6907 }
6908  
6909 0 ▶ if (pExtra_data != NULL)
Branch: 1 branch
BranchTrueFalseTotal
if (pExtra_data != NULL) 0 0 0
6910 {
6911 0 ▶ extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
Branch: 1 branch
BranchTrueFalseTotal
extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, 0 0 0
6912 0 ▶ (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
Branch: 2 branches
BranchTrueFalseTotal
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
(uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); 0 0 0
6913 }
6914  
6915 0 ▶ if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment, comment_size,
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment, comment_size, 0 0 0
6916 uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
6917 user_extra_data_central, user_extra_data_central_len))
6918 0 return MZ_FALSE;
6919  
6920 0 pZip->m_total_files++;
6921 0 pZip->m_archive_size = cur_archive_file_ofs;
6922  
6923 0 return MZ_TRUE;
6924 }
6925  
6926 #ifndef MINIZ_NO_STDIO
6927  
6928 static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
6929 {
6930 MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque;
6931 mz_int64 cur_ofs = MZ_FTELL64(pSrc_file);
6932  
6933 if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET))))
6934 return 0;
6935  
6936 return MZ_FREAD(pBuf, 1, n, pSrc_file);
6937 }
6938  
6939 mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
6940 const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
6941 {
6942 return mz_zip_writer_add_read_buf_callback(pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, pFile_time, pComment, comment_size, level_and_flags,
6943 user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
6944 }
6945  
6946 mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
6947 {
6948 MZ_FILE *pSrc_file = NULL;
6949 mz_uint64 uncomp_size = 0;
6950 MZ_TIME_T file_modified_time;
6951 MZ_TIME_T *pFile_time = NULL;
6952 mz_bool status;
6953  
6954 memset(&file_modified_time, 0, sizeof(file_modified_time));
6955  
6956 #if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
6957 pFile_time = &file_modified_time;
6958 if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
6959 return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED);
6960 #endif
6961  
6962 pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
6963 if (!pSrc_file)
6964 return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
6965  
6966 MZ_FSEEK64(pSrc_file, 0, SEEK_END);
6967 uncomp_size = MZ_FTELL64(pSrc_file);
6968 MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
6969  
6970 status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
6971  
6972 MZ_FCLOSE(pSrc_file);
6973  
6974 return status;
6975 }
6976 #endif /* #ifndef MINIZ_NO_STDIO */
6977  
6978 0 static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, mz_uint32 ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)
6979 {
6980 /* + 64 should be enough for any new zip64 data */
6981 0 ▶ if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE)) 0 0 0
if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE)) 0 0 0
6982 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
6983  
6984 mz_zip_array_resize(pZip, pNew_ext, 0, MZ_FALSE);
6985  
6986 0 ▶ if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start))
Branch: 4 branches
BranchTrueFalseTotal
if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) 0 0 0
if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) 0 0 0
if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) 0 0 0
if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) 0 0 0
6987 {
6988 mz_uint8 new_ext_block[64];
6989 0 mz_uint8 *pDst = new_ext_block;
6990 mz_write_le16(pDst, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID);
6991 0 mz_write_le16(pDst + sizeof(mz_uint16), 0);
6992 0 pDst += sizeof(mz_uint16) * 2;
6993  
6994 0 ▶ if (pUncomp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pUncomp_size) 0 0 0
6995 {
6996 0 mz_write_le64(pDst, *pUncomp_size);
6997 0 pDst += sizeof(mz_uint64);
6998 }
6999  
7000 0 ▶ if (pComp_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pComp_size) 0 0 0
7001 {
7002 0 mz_write_le64(pDst, *pComp_size);
7003 0 pDst += sizeof(mz_uint64);
7004 }
7005  
7006 0 ▶ if (pLocal_header_ofs)
Branch: 1 branch
BranchTrueFalseTotal
if (pLocal_header_ofs) 0 0 0
7007 {
7008 0 mz_write_le64(pDst, *pLocal_header_ofs);
7009 0 pDst += sizeof(mz_uint64);
7010 }
7011  
7012 0 ▶ if (pDisk_start)
Branch: 1 branch
BranchTrueFalseTotal
if (pDisk_start) 0 0 0
7013 {
7014 0 mz_write_le32(pDst, *pDisk_start);
7015 0 pDst += sizeof(mz_uint32);
7016 }
7017  
7018 0 mz_write_le16(new_ext_block + sizeof(mz_uint16), (mz_uint16)((pDst - new_ext_block) - sizeof(mz_uint16) * 2));
7019  
7020 0 ▶ if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block)) 0 0 0
if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block)) 0 0 0
7021 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7022 }
7023  
7024 0 ▶ if ((pExt) && (ext_len))
Branch: 2 branches
BranchTrueFalseTotal
if ((pExt) && (ext_len)) 0 0 0
if ((pExt) && (ext_len)) 0 0 0
7025 {
7026 0 mz_uint32 extra_size_remaining = ext_len;
7027 0 const mz_uint8 *pExtra_data = pExt;
7028  
7029 do
7030 {
7031 mz_uint32 field_id, field_data_size, field_total_size;
7032  
7033 0 ▶ if (extra_size_remaining < (sizeof(mz_uint16) * 2))
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) 0 0 0
7034 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7035  
7036 0 field_id = MZ_READ_LE16(pExtra_data);
7037 0 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
7038 0 field_total_size = field_data_size + sizeof(mz_uint16) * 2;
7039  
7040 0 ▶ if (field_total_size > extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if (field_total_size > extra_size_remaining) 0 0 0
7041 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7042  
7043 0 ▶ if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
Branch: 1 branch
BranchTrueFalseTotal
if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) 0 0 0
7044 {
7045 0 ▶ if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size)) 0 0 0
if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size)) 0 0 0
7046 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7047 }
7048  
7049 0 pExtra_data += field_total_size;
7050 0 extra_size_remaining -= field_total_size;
7051 0 ▶ } while (extra_size_remaining);
Branch: 1 branch
BranchTrueFalseTotal
} while (extra_size_remaining); 0 0 0
7052 }
7053  
7054 0 return MZ_TRUE;
7055 }
7056  
7057 /* TODO: This func is now pretty freakin complex due to zip64, split it up? */
7058 0 mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index)
7059 {
7060 mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
7061 mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
7062 mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
7063 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
7064 0 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
7065 mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
7066 size_t orig_central_dir_size;
7067 mz_zip_internal_state *pState;
7068 void *pBuf;
7069 const mz_uint8 *pSrc_central_header;
7070 mz_zip_archive_file_stat src_file_stat;
7071 mz_uint32 src_filename_len, src_comment_len, src_ext_len;
7072 mz_uint32 local_header_filename_size, local_header_extra_len;
7073 mz_uint64 local_header_comp_size, local_header_uncomp_size;
7074 0 mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
7075  
7076 /* Sanity checks */
7077 0 ▶ if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) 0 0 0
7078 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7079  
7080 0 pState = pZip->m_pState;
7081  
7082 /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */
7083 0 ▶ if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64))
Branch: 2 branches
BranchTrueFalseTotal
if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64)) 0 0 0
if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64)) 0 0 0
7084 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7085  
7086 /* Get pointer to the source central dir header and crack it */
7087 0 ▶ if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index)))
Branch: 1 branch
BranchTrueFalseTotal
if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index))) 0 0 0
7088 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7089  
7090 0 ▶ if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG) 0 0 0
7091 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7092  
7093 0 src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS);
7094 0 src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
7095 0 src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS);
7096 0 src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
7097  
7098 /* TODO: We don't support central dir's >= MZ_UINT32_MAX bytes right now (+32 fudge factor in case we need to add more extra data) */
7099 0 ▶ if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX) 0 0 0
7100 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
7101  
7102 0 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
7103  
7104 0 ▶ if (!pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->m_zip64) 0 0 0
7105 {
7106 0 ▶ if (pZip->m_total_files == MZ_UINT16_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT16_MAX) 0 0 0
7107 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
7108 }
7109 else
7110 {
7111 /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */
7112 0 ▶ if (pZip->m_total_files == MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files == MZ_UINT32_MAX) 0 0 0
7113 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
7114 }
7115  
7116 0 ▶ if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL)) 0 0 0
7117 0 return MZ_FALSE;
7118  
7119 0 cur_src_file_ofs = src_file_stat.m_local_header_ofs;
7120 0 cur_dst_file_ofs = pZip->m_archive_size;
7121  
7122 /* Read the source archive's local dir header */
7123 0 ▶ if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
7124 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
7125  
7126 0 ▶ if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
Branch: 1 branch
BranchTrueFalseTotal
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) 0 0 0
7127 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7128  
7129 0 cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
7130  
7131 /* Compute the total size we need to copy (filename+extra data+compressed data) */
7132 0 local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
7133 0 local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
7134 0 local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
7135 0 local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
7136 0 src_archive_bytes_remaining = src_file_stat.m_comp_size + local_header_filename_size + local_header_extra_len;
7137  
7138 /* Try to find a zip64 extended information field */
7139 0 ▶ if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
Branch: 3 branches
BranchTrueFalseTotal
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) 0 0 0
7140 {
7141 mz_zip_array file_data_array;
7142 const mz_uint8 *pExtra_data;
7143 0 mz_uint32 extra_size_remaining = local_header_extra_len;
7144  
7145 mz_zip_array_init(&file_data_array, 1);
7146 0 ▶ if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE)) 0 0 0
if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE)) 0 0 0
7147 {
7148 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7149 }
7150  
7151 0 ▶ if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, src_file_stat.m_local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_size, file_data_array.m_p, local_header_extra_len) != local_header_extra_len)
Branch: 1 branch
BranchTrueFalseTotal
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, src_file_stat.m_local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + local_header_filename_size, file_data_array.m_p, local_header_extra_len) != local_header_extra_len) 0 0 0
7152 {
7153 mz_zip_array_clear(pZip, &file_data_array);
7154 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
7155 }
7156  
7157 0 pExtra_data = (const mz_uint8 *)file_data_array.m_p;
7158  
7159 do
7160 {
7161 mz_uint32 field_id, field_data_size, field_total_size;
7162  
7163 0 ▶ if (extra_size_remaining < (sizeof(mz_uint16) * 2))
Branch: 1 branch
BranchTrueFalseTotal
if (extra_size_remaining < (sizeof(mz_uint16) * 2)) 0 0 0
7164 {
7165 mz_zip_array_clear(pZip, &file_data_array);
7166 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7167 }
7168  
7169 0 field_id = MZ_READ_LE16(pExtra_data);
7170 0 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
7171 0 field_total_size = field_data_size + sizeof(mz_uint16) * 2;
7172  
7173 0 ▶ if (field_total_size > extra_size_remaining)
Branch: 1 branch
BranchTrueFalseTotal
if (field_total_size > extra_size_remaining) 0 0 0
7174 {
7175 mz_zip_array_clear(pZip, &file_data_array);
7176 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7177 }
7178  
7179 0 ▶ if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)
Branch: 1 branch
BranchTrueFalseTotal
if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) 0 0 0
7180 {
7181 0 const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
7182  
7183 0 ▶ if (field_data_size < sizeof(mz_uint64) * 2)
Branch: 1 branch
BranchTrueFalseTotal
if (field_data_size < sizeof(mz_uint64) * 2) 0 0 0
7184 {
7185 mz_zip_array_clear(pZip, &file_data_array);
7186 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
7187 }
7188  
7189 0 local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
7190 0 local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */
7191  
7192 0 found_zip64_ext_data_in_ldir = MZ_TRUE;
7193 0 break;
7194 }
7195  
7196 0 pExtra_data += field_total_size;
7197 0 extra_size_remaining -= field_total_size;
7198 0 ▶ } while (extra_size_remaining);
Branch: 1 branch
BranchTrueFalseTotal
} while (extra_size_remaining); 0 0 0
7199  
7200 mz_zip_array_clear(pZip, &file_data_array);
7201 }
7202  
7203 0 ▶ if (!pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (!pState->m_zip64) 0 0 0
7204 {
7205 /* Try to detect if the new archive will most likely wind up too big and bail early (+(sizeof(mz_uint32) * 4) is for the optional descriptor which could be present, +64 is a fudge factor). */
7206 /* We also check when the archive is finalized so this doesn't need to be perfect. */
7207 0 mz_uint64 approx_new_archive_size = cur_dst_file_ofs + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + src_archive_bytes_remaining + (sizeof(mz_uint32) * 4) +
7208 0 pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 64;
7209  
7210 0 ▶ if (approx_new_archive_size >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (approx_new_archive_size >= MZ_UINT32_MAX) 0 0 0
7211 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
7212 }
7213  
7214 /* Write dest archive padding */
7215 0 ▶ if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes)) 0 0 0
7216 0 return MZ_FALSE;
7217  
7218 0 cur_dst_file_ofs += num_alignment_padding_bytes;
7219  
7220 0 local_dir_header_ofs = cur_dst_file_ofs;
7221 0 if (pZip->m_file_offset_alignment)
7222 {
7223 MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
7224 }
7225  
7226 /* The original zip's local header+ext block doesn't change, even with zip64, so we can just copy it over to the dest zip */
7227 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != MZ_ZIP_LOCAL_DIR_HEADER_SIZE) 0 0 0
7228 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7229  
7230 0 cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
7231  
7232 /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */
7233 0 ▶ if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining)))))
Branch: 2 branches
BranchTrueFalseTotal
if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining))))) 0 0 0
if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining))))) 0 0 0
7234 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7235  
7236 0 ▶ while (src_archive_bytes_remaining)
Branch: 1 branch
BranchTrueFalseTotal
while (src_archive_bytes_remaining) 0 0 0
7237 {
7238 0 ▶ n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining);
Branch: 1 branch
BranchTrueFalseTotal
n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining); 0 0 0
7239 0 ▶ if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
Branch: 1 branch
BranchTrueFalseTotal
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n) 0 0 0
7240 {
7241 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7242 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
7243 }
7244 0 cur_src_file_ofs += n;
7245  
7246 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) 0 0 0
7247 {
7248 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7249 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7250 }
7251 0 cur_dst_file_ofs += n;
7252  
7253 0 src_archive_bytes_remaining -= n;
7254 }
7255  
7256 /* Now deal with the optional data descriptor */
7257 0 bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
7258 0 ▶ if (bit_flags & 8)
Branch: 1 branch
BranchTrueFalseTotal
if (bit_flags & 8) 0 0 0
7259 {
7260 /* Copy data descriptor */
7261 0 ▶ if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
Branch: 2 branches
BranchTrueFalseTotal
if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir)) 0 0 0
if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir)) 0 0 0
7262 {
7263 /* src is zip64, dest must be zip64 */
7264  
7265 /* name uint32_t's */
7266 /* id 1 (optional in zip64?) */
7267 /* crc 1 */
7268 /* comp_size 2 */
7269 /* uncomp_size 2 */
7270 0 ▶ if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
Branch: 1 branch
BranchTrueFalseTotal
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6)) 0 0 0
7271 {
7272 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7273 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
7274 }
7275  
7276 0 ▶ n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5);
Branch: 1 branch
BranchTrueFalseTotal
n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5); 0 0 0
7277 }
7278 else
7279 {
7280 /* src is NOT zip64 */
7281 mz_bool has_id;
7282  
7283 0 ▶ if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
Branch: 1 branch
BranchTrueFalseTotal
if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4) 0 0 0
7284 {
7285 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7286 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);
7287 }
7288  
7289 0 has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
7290  
7291 0 ▶ if (pZip->m_pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pState->m_zip64) 0 0 0
7292 {
7293 /* dest is zip64, so upgrade the data descriptor */
7294 0 ▶ const mz_uint8 *pSrc_descriptor = (const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0);
Branch: 1 branch
BranchTrueFalseTotal
const mz_uint8 *pSrc_descriptor = (const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0); 0 0 0
7295 0 const mz_uint32 src_crc32 = MZ_READ_LE32(pSrc_descriptor);
7296 0 const mz_uint64 src_comp_size = MZ_READ_LE32(pSrc_descriptor + sizeof(mz_uint32));
7297 0 const mz_uint64 src_uncomp_size = MZ_READ_LE32(pSrc_descriptor + 2 * sizeof(mz_uint32));
7298  
7299 mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID);
7300 0 mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32);
7301 0 mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size);
7302 0 mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size);
7303  
7304 0 n = sizeof(mz_uint32) * 6;
7305 }
7306 else
7307 {
7308 /* dest is NOT zip64, just copy it as-is */
7309 0 ▶ n = sizeof(mz_uint32) * (has_id ? 4 : 3);
Branch: 1 branch
BranchTrueFalseTotal
n = sizeof(mz_uint32) * (has_id ? 4 : 3); 0 0 0
7310 }
7311 }
7312  
7313 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) 0 0 0
7314 {
7315 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7316 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7317 }
7318  
7319 0 cur_src_file_ofs += n;
7320 0 cur_dst_file_ofs += n;
7321 }
7322 0 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7323  
7324 /* Finally, add the new central dir header */
7325 0 orig_central_dir_size = pState->m_central_dir.m_size;
7326  
7327 0 memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
7328  
7329 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
7330 {
7331 /* This is the painful part: We need to write a new central dir header + ext block with updated zip64 fields, and ensure the old fields (if any) are not included. */
7332 0 const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len;
7333 mz_zip_array new_ext_block;
7334  
7335 mz_zip_array_init(&new_ext_block, sizeof(mz_uint8));
7336  
7337 0 MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
7338 0 MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_UINT32_MAX);
7339 0 MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_UINT32_MAX);
7340  
7341 0 ▶ if (!mz_zip_writer_update_zip64_extension_block(&new_ext_block, pZip, pSrc_ext, src_ext_len, &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, &local_dir_header_ofs, NULL))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_update_zip64_extension_block(&new_ext_block, pZip, pSrc_ext, src_ext_len, &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, &local_dir_header_ofs, NULL)) 0 0 0
7342 {
7343 mz_zip_array_clear(pZip, &new_ext_block);
7344 0 return MZ_FALSE;
7345 }
7346  
7347 0 MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size);
7348  
7349 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
7350 {
7351 mz_zip_array_clear(pZip, &new_ext_block);
7352 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7353 }
7354  
7355 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len)) 0 0 0
7356 {
7357 mz_zip_array_clear(pZip, &new_ext_block);
7358 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7359 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7360 }
7361  
7362 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size)) 0 0 0
7363 {
7364 mz_zip_array_clear(pZip, &new_ext_block);
7365 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7366 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7367 }
7368  
7369 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len + src_ext_len, src_comment_len)) 0 0 0
7370 {
7371 mz_zip_array_clear(pZip, &new_ext_block);
7372 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7373 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7374 }
7375  
7376 mz_zip_array_clear(pZip, &new_ext_block);
7377 }
7378 else
7379 {
7380 /* sanity checks */
7381 0 ▶ if (cur_dst_file_ofs > MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (cur_dst_file_ofs > MZ_UINT32_MAX) 0 0 0
7382 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
7383  
7384 0 ▶ if (local_dir_header_ofs >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (local_dir_header_ofs >= MZ_UINT32_MAX) 0 0 0
7385 0 return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE);
7386  
7387 0 MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
7388  
7389 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) 0 0 0
7390 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7391  
7392 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_central_dir_following_data_size)) 0 0 0
7393 {
7394 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7395 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7396 }
7397 }
7398  
7399 /* This shouldn't trigger unless we screwed up during the initial sanity checks */
7400 0 ▶ if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) 0 0 0
7401 {
7402 /* TODO: Support central dirs >= 32-bits in size */
7403 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7404 0 return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);
7405 }
7406  
7407 0 n = (mz_uint32)orig_central_dir_size;
7408 0 ▶ if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
Branch: 2 branches
BranchTrueFalseTotal
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1)) 0 0 0
if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1)) 0 0 0
7409 {
7410 0 ▶ mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
Branch: 1 branch
BranchTrueFalseTotal
mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); 0 0 0
7411 0 return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);
7412 }
7413  
7414 0 pZip->m_total_files++;
7415 0 pZip->m_archive_size = cur_dst_file_ofs;
7416  
7417 0 return MZ_TRUE;
7418 }
7419  
7420 0 mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
7421 {
7422 mz_zip_internal_state *pState;
7423 mz_uint64 central_dir_ofs, central_dir_size;
7424 mz_uint8 hdr[256];
7425  
7426 0 ▶ if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
Branch: 3 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) 0 0 0
7427 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7428  
7429 0 pState = pZip->m_pState;
7430  
7431 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
7432 {
7433 0 ▶ if ((mz_uint64)pState->m_central_dir.m_size >= MZ_UINT32_MAX)
Branch: 1 branch
BranchTrueFalseTotal
if ((mz_uint64)pState->m_central_dir.m_size >= MZ_UINT32_MAX) 0 0 0
7434 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
7435 }
7436 else
7437 {
7438 0 ▶ if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX))
Branch: 2 branches
BranchTrueFalseTotal
if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)) 0 0 0
if ((pZip->m_total_files > MZ_UINT16_MAX) || ((pZip->m_archive_size + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)) 0 0 0
7439 0 return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
7440 }
7441  
7442 0 central_dir_ofs = 0;
7443 0 central_dir_size = 0;
7444 0 ▶ if (pZip->m_total_files)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_total_files) 0 0 0
7445 {
7446 /* Write central directory */
7447 0 central_dir_ofs = pZip->m_archive_size;
7448 0 central_dir_size = pState->m_central_dir.m_size;
7449 0 pZip->m_central_directory_file_ofs = central_dir_ofs;
7450 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, pState->m_central_dir.m_p, (size_t)central_dir_size) != central_dir_size) 0 0 0
7451 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7452  
7453 0 pZip->m_archive_size += central_dir_size;
7454 }
7455  
7456 0 ▶ if (pState->m_zip64)
Branch: 1 branch
BranchTrueFalseTotal
if (pState->m_zip64) 0 0 0
7457 {
7458 /* Write zip64 end of central directory header */
7459 0 mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size;
7460  
7461 0 MZ_CLEAR_ARR(hdr);
7462 MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG);
7463 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - sizeof(mz_uint64));
7464 0 MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */
7465 0 MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D);
7466 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files);
7467 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files);
7468 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size);
7469 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs);
7470 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
7471 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7472  
7473 0 pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
7474  
7475 /* Write zip64 end of central directory locator */
7476 0 MZ_CLEAR_ARR(hdr);
7477 MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG);
7478 0 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr);
7479 0 MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1);
7480 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) 0 0 0
7481 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7482  
7483 0 pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
7484 }
7485  
7486 /* Write end of central directory record */
7487 0 MZ_CLEAR_ARR(hdr);
7488 MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG);
7489 0 ▶ MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); 0 0 0
7490 0 ▶ MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); 0 0 0
7491 0 ▶ MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size)); 0 0 0
7492 0 ▶ MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs));
Branch: 1 branch
BranchTrueFalseTotal
MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs)); 0 0 0
7493  
7494 0 ▶ if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) 0 0 0
7495 0 return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED);
7496  
7497 #ifndef MINIZ_NO_STDIO
7498 if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
7499 return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED);
7500 #endif /* #ifndef MINIZ_NO_STDIO */
7501  
7502 0 pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE;
7503  
7504 0 pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED;
7505 0 return MZ_TRUE;
7506 }
7507  
7508 0 mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
7509 {
7510 0 ▶ if ((!ppBuf) || (!pSize))
Branch: 2 branches
BranchTrueFalseTotal
if ((!ppBuf) || (!pSize)) 0 0 0
if ((!ppBuf) || (!pSize)) 0 0 0
7511 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7512  
7513 0 *ppBuf = NULL;
7514 0 *pSize = 0;
7515  
7516 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
7517 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7518  
7519 0 ▶ if (pZip->m_pWrite != mz_zip_heap_write_func)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_pWrite != mz_zip_heap_write_func) 0 0 0
7520 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7521  
7522 0 ▶ if (!mz_zip_writer_finalize_archive(pZip))
Branch: 1 branch
BranchTrueFalseTotal
if (!mz_zip_writer_finalize_archive(pZip)) 0 0 0
7523 0 return MZ_FALSE;
7524  
7525 0 *ppBuf = pZip->m_pState->m_pMem;
7526 0 *pSize = pZip->m_pState->m_mem_size;
7527 0 pZip->m_pState->m_pMem = NULL;
7528 0 pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
7529  
7530 0 return MZ_TRUE;
7531 }
7532  
7533 0 mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
7534 {
7535 0 return mz_zip_writer_end_internal(pZip, MZ_TRUE);
7536 }
7537  
7538 #ifndef MINIZ_NO_STDIO
7539 mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags)
7540 {
7541 return mz_zip_add_mem_to_archive_file_in_place_v2(pZip_filename, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, NULL);
7542 }
7543  
7544 mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr)
7545 {
7546 mz_bool status, created_new_archive = MZ_FALSE;
7547 mz_zip_archive zip_archive;
7548 struct MZ_FILE_STAT_STRUCT file_stat;
7549 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
7550  
7551 mz_zip_zero_struct(&zip_archive);
7552 if ((int)level_and_flags < 0)
7553 level_and_flags = MZ_DEFAULT_LEVEL;
7554  
7555 if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
7556 {
7557 if (pErr)
7558 *pErr = MZ_ZIP_INVALID_PARAMETER;
7559 return MZ_FALSE;
7560 }
7561  
7562 if (!mz_zip_writer_validate_archive_name(pArchive_name))
7563 {
7564 if (pErr)
7565 *pErr = MZ_ZIP_INVALID_FILENAME;
7566 return MZ_FALSE;
7567 }
7568  
7569 /* Important: The regular non-64 bit version of stat() can fail here if the file is very large, which could cause the archive to be overwritten. */
7570 /* So be sure to compile with _LARGEFILE64_SOURCE 1 */
7571 if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
7572 {
7573 /* Create a new archive. */
7574 if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags))
7575 {
7576 if (pErr)
7577 *pErr = zip_archive.m_last_error;
7578 return MZ_FALSE;
7579 }
7580  
7581 created_new_archive = MZ_TRUE;
7582 }
7583 else
7584 {
7585 /* Append to an existing archive. */
7586 if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY | MZ_ZIP_FLAG_READ_ALLOW_WRITING, 0, 0))
7587 {
7588 if (pErr)
7589 *pErr = zip_archive.m_last_error;
7590 return MZ_FALSE;
7591 }
7592  
7593 if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_READ_ALLOW_WRITING))
7594 {
7595 if (pErr)
7596 *pErr = zip_archive.m_last_error;
7597  
7598 mz_zip_reader_end_internal(&zip_archive, MZ_FALSE);
7599  
7600 return MZ_FALSE;
7601 }
7602 }
7603  
7604 status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
7605 actual_err = zip_archive.m_last_error;
7606  
7607 /* Always finalize, even if adding failed for some reason, so we have a valid central directory. (This may not always succeed, but we can try.) */
7608 if (!mz_zip_writer_finalize_archive(&zip_archive))
7609 {
7610 if (!actual_err)
7611 actual_err = zip_archive.m_last_error;
7612  
7613 status = MZ_FALSE;
7614 }
7615  
7616 if (!mz_zip_writer_end_internal(&zip_archive, status))
7617 {
7618 if (!actual_err)
7619 actual_err = zip_archive.m_last_error;
7620  
7621 status = MZ_FALSE;
7622 }
7623  
7624 if ((!status) && (created_new_archive))
7625 {
7626 /* It's a new archive and something went wrong, so just delete it. */
7627 int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
7628 (void)ignoredStatus;
7629 }
7630  
7631 if (pErr)
7632 *pErr = actual_err;
7633  
7634 return status;
7635 }
7636  
7637 void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr)
7638 {
7639 mz_uint32 file_index;
7640 mz_zip_archive zip_archive;
7641 void *p = NULL;
7642  
7643 if (pSize)
7644 *pSize = 0;
7645  
7646 if ((!pZip_filename) || (!pArchive_name))
7647 {
7648 if (pErr)
7649 *pErr = MZ_ZIP_INVALID_PARAMETER;
7650  
7651 return NULL;
7652 }
7653  
7654 mz_zip_zero_struct(&zip_archive);
7655 if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
7656 {
7657 if (pErr)
7658 *pErr = zip_archive.m_last_error;
7659  
7660 return NULL;
7661 }
7662  
7663 if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
7664 {
7665 p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
7666 }
7667  
7668 mz_zip_reader_end_internal(&zip_archive, p != NULL);
7669  
7670 if (pErr)
7671 *pErr = zip_archive.m_last_error;
7672  
7673 return p;
7674 }
7675  
7676 void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags)
7677 {
7678 return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL);
7679 }
7680  
7681 #endif /* #ifndef MINIZ_NO_STDIO */
7682  
7683 #endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */
7684  
7685 /* ------------------- Misc utils */
7686  
7687 0 mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip)
7688 {
7689 0 ▶ return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID;
Branch: 1 branch
BranchTrueFalseTotal
return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID; 0 0 0
7690 }
7691  
7692 0 mz_zip_type mz_zip_get_type(mz_zip_archive *pZip)
7693 {
7694 0 ▶ return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID;
Branch: 1 branch
BranchTrueFalseTotal
return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID; 0 0 0
7695 }
7696  
7697 0 mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
7698 {
7699 mz_zip_error prev_err;
7700  
7701 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
7702 0 return MZ_ZIP_INVALID_PARAMETER;
7703  
7704 0 prev_err = pZip->m_last_error;
7705  
7706 0 pZip->m_last_error = err_num;
7707 0 return prev_err;
7708 }
7709  
7710 0 mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip)
7711 {
7712 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
7713 0 return MZ_ZIP_INVALID_PARAMETER;
7714  
7715 0 return pZip->m_last_error;
7716 }
7717  
7718 0 mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip)
7719 {
7720 0 return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR);
7721 }
7722  
7723 0 mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip)
7724 {
7725 mz_zip_error prev_err;
7726  
7727 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
7728 0 return MZ_ZIP_INVALID_PARAMETER;
7729  
7730 0 prev_err = pZip->m_last_error;
7731  
7732 0 pZip->m_last_error = MZ_ZIP_NO_ERROR;
7733 0 return prev_err;
7734 }
7735  
7736 0 const char *mz_zip_get_error_string(mz_zip_error mz_err)
7737 {
7738 0 switch (mz_err)
7739 {
7740 0 case MZ_ZIP_NO_ERROR:
7741 0 return "no error";
7742 0 case MZ_ZIP_UNDEFINED_ERROR:
7743 0 return "undefined error";
7744 0 case MZ_ZIP_TOO_MANY_FILES:
7745 0 return "too many files";
7746 0 case MZ_ZIP_FILE_TOO_LARGE:
7747 0 return "file too large";
7748 0 case MZ_ZIP_UNSUPPORTED_METHOD:
7749 0 return "unsupported method";
7750 0 case MZ_ZIP_UNSUPPORTED_ENCRYPTION:
7751 0 return "unsupported encryption";
7752 0 case MZ_ZIP_UNSUPPORTED_FEATURE:
7753 0 return "unsupported feature";
7754 0 case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR:
7755 0 return "failed finding central directory";
7756 0 case MZ_ZIP_NOT_AN_ARCHIVE:
7757 0 return "not a ZIP archive";
7758 0 case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED:
7759 0 return "invalid header or archive is corrupted";
7760 0 case MZ_ZIP_UNSUPPORTED_MULTIDISK:
7761 0 return "unsupported multidisk archive";
7762 0 case MZ_ZIP_DECOMPRESSION_FAILED:
7763 0 return "decompression failed or archive is corrupted";
7764 0 case MZ_ZIP_COMPRESSION_FAILED:
7765 0 return "compression failed";
7766 0 case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE:
7767 0 return "unexpected decompressed size";
7768 0 case MZ_ZIP_CRC_CHECK_FAILED:
7769 0 return "CRC-32 check failed";
7770 0 case MZ_ZIP_UNSUPPORTED_CDIR_SIZE:
7771 0 return "unsupported central directory size";
7772 0 case MZ_ZIP_ALLOC_FAILED:
7773 0 return "allocation failed";
7774 0 case MZ_ZIP_FILE_OPEN_FAILED:
7775 0 return "file open failed";
7776 0 case MZ_ZIP_FILE_CREATE_FAILED:
7777 0 return "file create failed";
7778 0 case MZ_ZIP_FILE_WRITE_FAILED:
7779 0 return "file write failed";
7780 0 case MZ_ZIP_FILE_READ_FAILED:
7781 0 return "file read failed";
7782 0 case MZ_ZIP_FILE_CLOSE_FAILED:
7783 0 return "file close failed";
7784 0 case MZ_ZIP_FILE_SEEK_FAILED:
7785 0 return "file seek failed";
7786 0 case MZ_ZIP_FILE_STAT_FAILED:
7787 0 return "file stat failed";
7788 0 case MZ_ZIP_INVALID_PARAMETER:
7789 0 return "invalid parameter";
7790 0 case MZ_ZIP_INVALID_FILENAME:
7791 0 return "invalid filename";
7792 0 case MZ_ZIP_BUF_TOO_SMALL:
7793 0 return "buffer too small";
7794 0 case MZ_ZIP_INTERNAL_ERROR:
7795 0 return "internal error";
7796 0 case MZ_ZIP_FILE_NOT_FOUND:
7797 0 return "file not found";
7798 0 case MZ_ZIP_ARCHIVE_TOO_LARGE:
7799 0 return "archive is too large";
7800 0 case MZ_ZIP_VALIDATION_FAILED:
7801 0 return "validation failed";
7802 0 case MZ_ZIP_WRITE_CALLBACK_FAILED:
7803 0 return "write callback failed";
7804 0 case MZ_ZIP_TOTAL_ERRORS:
7805 0 return "total errors";
7806 0 default:
7807 0 break;
7808 }
7809  
7810 0 return "unknown error";
7811 }
7812  
7813 /* Note: Just because the archive is not zip64 doesn't necessarily mean it doesn't have Zip64 extended information extra field, argh. */
7814 0 mz_bool mz_zip_is_zip64(mz_zip_archive *pZip)
7815 {
7816 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
7817 0 return MZ_FALSE;
7818  
7819 0 return pZip->m_pState->m_zip64;
7820 }
7821  
7822 0 size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip)
7823 {
7824 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
7825 0 return 0;
7826  
7827 0 return pZip->m_pState->m_central_dir.m_size;
7828 }
7829  
7830 0 mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip)
7831 {
7832 0 ▶ return pZip ? pZip->m_total_files : 0;
Branch: 1 branch
BranchTrueFalseTotal
return pZip ? pZip->m_total_files : 0; 0 0 0
7833 }
7834  
7835 0 mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip)
7836 {
7837 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
7838 0 return 0;
7839 0 return pZip->m_archive_size;
7840 }
7841  
7842 0 mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip)
7843 {
7844 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
7845 0 return 0;
7846 0 return pZip->m_pState->m_file_archive_start_ofs;
7847 }
7848  
7849 0 MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip)
7850 {
7851 0 ▶ if ((!pZip) || (!pZip->m_pState))
Branch: 2 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState)) 0 0 0
if ((!pZip) || (!pZip->m_pState)) 0 0 0
7852 0 return 0;
7853 0 return pZip->m_pState->m_pFile;
7854 }
7855  
7856 0 size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)
7857 {
7858 0 ▶ if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead))
Branch: 4 branches
BranchTrueFalseTotal
if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) 0 0 0
if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) 0 0 0
7859 0 return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7860  
7861 0 return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n);
7862 }
7863  
7864 0 ▶ mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size) 0 0 0
7865 {
7866 mz_uint n;
7867 0 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
7868 0 ▶ if (!p)
Branch: 1 branch
BranchTrueFalseTotal
if (!p) 0 0 0
7869 {
7870 0 ▶ if (filename_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (filename_buf_size) 0 0 0
7871 0 pFilename[0] = '\0';
7872 mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
7873 0 return 0;
7874 }
7875 0 n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
7876 0 ▶ if (filename_buf_size)
Branch: 1 branch
BranchTrueFalseTotal
if (filename_buf_size) 0 0 0
7877 {
7878 0 n = MZ_MIN(n, filename_buf_size - 1);
7879 0 memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
7880 0 pFilename[n] = '\0';
7881 }
7882 0 return n + 1;
7883 }
7884  
7885 0 ▶ mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
Branch: 1 branch
BranchTrueFalseTotal
mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat) 0 0 0
7886 {
7887 0 return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
7888 }
7889  
7890 0 mz_bool mz_zip_end(mz_zip_archive *pZip)
7891 {
7892 0 ▶ if (!pZip)
Branch: 1 branch
BranchTrueFalseTotal
if (!pZip) 0 0 0
7893 0 return MZ_FALSE;
7894  
7895 0 ▶ if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
Branch: 1 branch
BranchTrueFalseTotal
if (pZip->m_zip_mode == MZ_ZIP_MODE_READING) 0 0 0
7896 0 return mz_zip_reader_end(pZip);
7897 #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
7898 0 ▶ else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))
Branch: 2 branches
BranchTrueFalseTotal
else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)) 0 0 0
else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)) 0 0 0
7899 0 return mz_zip_writer_end(pZip);
7900 #endif
7901  
7902 0 return MZ_FALSE;
7903 }
7904  
7905 #ifdef __cplusplus
7906 }
7907 #endif
7908  
7909 #endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/
« blib/lib/Sereal/Performance.pm ↑ Summary snappy/csnappy_decompress.c »