diff --git a/ptx/binwalk-I-ptx.txt b/ptx/binwalk-I-ptx.txt new file mode 100644 index 0000000..70b6fcf --- /dev/null +++ b/ptx/binwalk-I-ptx.txt @@ -0,0 +1,378 @@ + +Scan Time: 2025-07-15 23:28:35 +Target File: /mnt/c/Users/human/Downloads/Untitled2.ptx +MD5 Checksum: 304ac5a4b10bbec799347d8ebb867a1f +Signatures: 436 + +DECIMAL HEXADECIMAL DESCRIPTION +-------------------------------------------------------------------------------- +9 0x9 VxWorks symbol table, little endian, first entry: [type: function, code address: 0x31313031, symbol address: 0x30313030],,,,,,,,, +438 0x1B6 Intel x86 or x64 microcode, pf_mask 0x10, 0000-00-00, size 22675456 +636 0x27C Intel x86 or x64 microcode, sig 0x5a203200, pf_mask 0x00, 2A00-00-00, rev 0x25a0000, size 2048 +665 0x299 Intel x86 or x64 microcode, pf_mask 0x15a0200, 0000-00-06, size 998656 +850 0x352 Intel x86 or x64 microcode, pf_mask 0x1000001, FFEE-00-00, rev 0x3c0000, size 5 +906 0x38A Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x10000, size 2048 +912 0x390 Intel x86 or x64 microcode, sig 0x00000100, pf_mask 0x00, 0000-00-00, size 2048 +928 0x3A0 Intel x86 or x64 microcode, sig 0x01000000, pf_mask 0x10000, 0000-00-00, rev 0x10000, size 65536 +934 0x3A6 Intel x86 or x64 microcode, pf_mask 0x00, 0100-00-00, size 2048 +943 0x3AF Intel x86 or x64 microcode, sig 0x00190000, pf_mask 0x00, 0000-01-00, rev 0x3000000, size 19660800 +965 0x3C5 Intel x86 or x64 microcode, sig 0x0000012c, pf_mask 0x1010000, 0000-00-00, size 3321889882 +978 0x3D2 Intel x86 or x64 microcode, sig 0x00010100, pf_mask 0x10400000, 0000-00-00, size 1023410176 +992 0x3E0 Intel x86 or x64 microcode, sig 0x025a1040, pf_mask 0x00, 02C6-00-00, rev 0x45a00, size 4263244 +1151 0x47F Intel x86 or x64 microcode, pf_mask 0x40000000, 0000-40-00, rev 0x0001, size 1073741824 +1155 0x483 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 2048 +1219 0x4C3 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x01, 0000-00-00, rev 0x40000000, size 1 +1243 0x4DB Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x32, 0001-00-00, rev 0x40000000, size 2048 +1251 0x4E3 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 1073741824 +1287 0x507 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x32, 000A-00-00, rev 0x40000000, size 1073741824 +1304 0x518 Intel x86 or x64 microcode, pf_mask 0x1400000, 0000-01-00, rev 0x32400000, size 4194304 +1315 0x523 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 1 +1331 0x533 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x09, 0000-00-00, rev 0x40000000, size 1056964608 +1347 0x543 Intel x86 or x64 microcode, sig 0x3a00015a, pf_mask 0x100, 0009-00-00, rev 0x0006, size 256 +1368 0x558 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x01, 0040-00-00, rev 0x0001, size 1 +1372 0x55C Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x7f, 0001-00-00, rev 0x0040, size 400 +1380 0x564 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x190, 00C8-00-00, rev 0x0001, size 1 +1384 0x568 Intel x86 or x64 microcode, sig 0x0000007f, pf_mask 0x00, 0001-00-00, rev 0x00c8, size 127 +1392 0x570 Intel x86 or x64 microcode, sig 0x00000190, pf_mask 0x7f, 0001-00-00, rev 0x007f, size 1627390554 +1400 0x578 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x6100025a, 0000-00-00, rev 0x0190, size 16842768 +1405 0x57D Intel x86 or x64 microcode, pf_mask 0x10410000, 0000-7F-00, rev 0x1000000, size 1677747200 +1412 0x584 Intel x86 or x64 microcode, sig 0x6100025a, pf_mask 0x640000, 0000-00-00, rev 0x007f, size 1769472 +1494 0x5D6 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 22675558 +1680 0x690 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 56229953 +1732 0x6C4 Intel x86 or x64 microcode, sig 0xe0000000, pf_mask 0x25a3f, 0000-00-00, size 16785534 +1779 0x6F3 Intel x86 or x64 microcode, sig 0x20490000, pf_mask 0x1f4, 0002-00-16, rev 0x5a010000, size 2048 +1804 0x70C Intel x86 or x64 microcode, sig 0x00710004, pf_mask 0x00, 0000-5A-00, size 2048 +1844 0x734 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x0001, size 4 +1848 0x738 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x00, 0000-00-00, size 4 +1860 0x744 Intel x86 or x64 microcode, pf_mask 0x30001, 0000-00-00, rev 0x0001, size 2 +1864 0x748 Intel x86 or x64 microcode, sig 0x00000004, pf_mask 0x00, 0000-00-00, size 3 +2095 0x82F Intel x86 or x64 microcode, pf_mask 0x3d0002, 8010-00-01, size 257 +2105 0x839 Intel x86 or x64 microcode, sig 0x00025a01, pf_mask 0x00, 0101-01-00, rev 0x20000, size 2048 +2128 0x850 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x1010000, size 2048 +2135 0x857 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 2048 +2196 0x894 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x1000000, size 2048 +2203 0x89B Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 2048 +2269 0x8DD EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 340848 blocks, 0x532 pages per block, 0x616e5300 bytes per page +2278 0x8E6 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341104 blocks, 0x533 pages per block, 0x616e5300 bytes per page +2287 0x8EF EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341360 blocks, 0x534 pages per block, 0x616e5300 bytes per page +2296 0x8F8 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341616 blocks, 0x535 pages per block, 0x616e5300 bytes per page +2305 0x901 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341872 blocks, 0x536 pages per block, 0x616e5300 bytes per page +2314 0x90A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 342128 blocks, 0x537 pages per block, 0x616e5300 bytes per page +2323 0x913 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 407920 blocks, 0x538 pages per block, 0x616e5300 bytes per page +2332 0x91C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 103821680 blocks, 0x639 pages per block, 0x616e5300 bytes per page +2341 0x925 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 825323617 blocks, 0x63031 pages per block, 0x6e530000 bytes per page +2350 0x92E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6313170 pages per block, 0x53000000 bytes per page +2360 0x938 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6323170 pages per block, 0x53000000 bytes per page +2370 0x942 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6333170 pages per block, 0x53000000 bytes per page +2380 0x94C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6343170 pages per block, 0x53000000 bytes per page +2390 0x956 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6353170 pages per block, 0x53000000 bytes per page +2400 0x960 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6363170 pages per block, 0x53000000 bytes per page +2410 0x96A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6373170 pages per block, 0x53000000 bytes per page +2420 0x974 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6383170 pages per block, 0x53000000 bytes per page +2430 0x97E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6393170 pages per block, 0x53000000 bytes per page +2440 0x988 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6303270 pages per block, 0x53000000 bytes per page +2450 0x992 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6313270 pages per block, 0x53000000 bytes per page +2460 0x99C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6323270 pages per block, 0x53000000 bytes per page +2470 0x9A6 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6333270 pages per block, 0x53000000 bytes per page +2480 0x9B0 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6343270 pages per block, 0x53000000 bytes per page +2490 0x9BA EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6353270 pages per block, 0x53000000 bytes per page +2500 0x9C4 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6363270 pages per block, 0x53000000 bytes per page +2510 0x9CE EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6373270 pages per block, 0x53000000 bytes per page +2520 0x9D8 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6383270 pages per block, 0x53000000 bytes per page +2530 0x9E2 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6393270 pages per block, 0x53000000 bytes per page +2540 0x9EC EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6303370 pages per block, 0x53000000 bytes per page +2550 0x9F6 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6313370 pages per block, 0x53000000 bytes per page +2560 0xA00 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6323370 pages per block, 0x53000000 bytes per page +2570 0xA0A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6333370 pages per block, 0x53000000 bytes per page +2580 0xA14 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6343370 pages per block, 0x53000000 bytes per page +2590 0xA1E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6353370 pages per block, 0x53000000 bytes per page +2600 0xA28 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6363370 pages per block, 0x53000000 bytes per page +2610 0xA32 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6373370 pages per block, 0x53000000 bytes per page +2620 0xA3C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6383370 pages per block, 0x53000000 bytes per page +2630 0xA46 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6393370 pages per block, 0x53000000 bytes per page +2640 0xA50 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6303470 pages per block, 0x53000000 bytes per page +2650 0xA5A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6313470 pages per block, 0x53000000 bytes per page +2660 0xA64 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6323470 pages per block, 0x53000000 bytes per page +2670 0xA6E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6333470 pages per block, 0x53000000 bytes per page +2680 0xA78 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6343470 pages per block, 0x53000000 bytes per page +2690 0xA82 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6353470 pages per block, 0x53000000 bytes per page +2700 0xA8C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6363470 pages per block, 0x53000000 bytes per page +2710 0xA96 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6373470 pages per block, 0x53000000 bytes per page +2720 0xAA0 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 542507008 blocks, 0x5a383470 pages per block, 0x2b0006 bytes per page +2730 0xAAA EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 67108864 blocks, 0x12056 pages per block, 0x0 bytes per page +2748 0xABC Intel x86 or x64 microcode, sig 0x00000200, pf_mask 0x00, 0400-00-00, size 16777216 +2783 0xADF Intel x86 or x64 microcode, sig 0x03202400, pf_mask 0x5b, 6A00-00-00, rev 0x65a0050, size 218103808 +2916 0xB64 Intel x86 or x64 microcode, sig 0x0000000d, pf_mask 0x50b09, 0000-01-00, rev 0x0101, size 41 +2921 0xB69 Intel x86 or x64 microcode, sig 0x030a0201, pf_mask 0x2900035a, 0000-00-00, rev 0xd010000, size 288 +2954 0xB8A Intel x86 or x64 microcode, sig 0x00000120, pf_mask 0xfbdc0002, 0000-7A-00, rev 0x1c00025a, size 16777215 +2967 0xB97 Intel x86 or x64 microcode, sig 0xfffbdc00, pf_mask 0x45a0000, 0241-02-00, rev 0x0001, size 119557376 +2971 0xB9B Intel x86 or x64 microcode, sig 0xffff00ff, pf_mask 0x2a00, DC00-FF-FB, rev 0x2000241, size 16777216 +3006 0xBBE Intel x86 or x64 microcode, sig 0x00000100, pf_mask 0x3a343200, 0100-14-01, size 808466992 +3019 0xBCB Intel x86 or x64 microcode, sig 0x303a3432, pf_mask 0x60001, 000B-00-00, rev 0x0007, size 2048 +3198 0xC7E Intel x86 or x64 microcode, sig 0x000a0410, pf_mask 0x63696e6f, 0000-17-00, rev 0x3f00055a, size 1181051984 +3240 0xCA8 Intel x86 or x64 microcode, sig 0x6976612e, pf_mask 0x322e616c, 6300-6D-6F, rev 0x1700, size 1426063706 +3316 0xCF4 Intel x86 or x64 microcode, sig 0x4fce34d4, pf_mask 0x00, 6900-43-BA, rev 0x2a00, size 88576 +3407 0xD4F Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x424, 0101-00-00, rev 0x1010100, size 2048 +3416 0xD58 Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1342178409 +3467 0xD8B Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40426, 0101-00-00, rev 0x1010100, size 2048 +3476 0xD94 Intel x86 or x64 microcode, sig 0x26260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3527 0xDC7 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40424, 0101-00-00, rev 0x1010100, size 2048 +3536 0xDD0 Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 4600-00-00, rev 0x65a0000, size 2614349582 +3604 0xE14 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40425, 0101-00-00, rev 0x1010100, size 2048 +3613 0xE1D Intel x86 or x64 microcode, sig 0x25260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 416562889 +3664 0xE50 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b4040b, 0101-00-00, rev 0x1010100, size 2048 +3673 0xE59 Intel x86 or x64 microcode, sig 0x0b260000, pf_mask 0x2a000000, 4100-00-00, rev 0x65a0000, size 2027085277 +3736 0xE98 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980425, 0101-00-00, rev 0x1010100, size 2048 +3745 0xEA1 Intel x86 or x64 microcode, sig 0x25260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3796 0xED4 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40427, 0101-00-00, rev 0x1010100, size 2048 +3805 0xEDD Intel x86 or x64 microcode, sig 0x27260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3856 0xF10 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980427, 0101-00-00, rev 0x1010100, size 2048 +3865 0xF19 Intel x86 or x64 microcode, sig 0x27260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3916 0xF4C Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980426, 0101-00-00, rev 0x1010100, size 2048 +3925 0xF55 Intel x86 or x64 microcode, sig 0x26260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3976 0xF88 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980424, 0101-00-00, rev 0x1010100, size 2048 +3985 0xF91 Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 4600-00-00, rev 0x65a0000, size 2614349582 +4053 0xFD5 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x198040b, 0101-00-00, rev 0x1010100, size 2048 +4062 0xFDE Intel x86 or x64 microcode, sig 0x0b260000, pf_mask 0x2a000000, 4100-00-00, rev 0x65a0000, size 264360332 +13626 0x353A ARJ archive data, header size: -6659, version -103, minimum version to extract: -108, slash-switched, backup, , original name: "066666<‚Á666666666r5€åê&f«3666w7766666777766666É6l56t66644676667666 6n6766666666_Œuâœøy", original file date: 1984-05-15 06:08:55, compressed file size: 909588228, uncompressed file size: 909522486, +20768 0x5120 ESP Image flash speed: 26MHz, entry address: 0x144d8be6, +20870 0x5186 ESP Image flash speed: 26MHz, entry address: 0x144d8be6, +23478 0x5BB6 Microsoft executable, +26049 0x65C1 BFF volume entry, compressed, file size: 1819048044, compressed size: 1228893292, file name: "l0hlllÈlllmlllmmmmlmlllllllŒ÷ |,lllL]y,allllmlllmmlllllmllllmllmmm6mlKlllàIglll^lldlm_lmmlmnlmolmhlmilmkllelmjlmm@llllúllllmm" +34111 0x853F ESP Image flash speed: 40MHz, entry address: 0x90909090, +34138 0x855A ESP Image flash speed: 40MHz, entry address: 0x90909090, +34194 0x8592 ESP Image flash speed: 40MHz, entry address: 0x90909090, + + +Scan Time: 2025-07-15 23:28:35 +Target File: /mnt/c/Users/human/Downloads/Untitled [RAWBASE].ptx +MD5 Checksum: fe5549de9c51beb034cd0ad19f1a95f8 +Signatures: 436 + +DECIMAL HEXADECIMAL DESCRIPTION +-------------------------------------------------------------------------------- +9 0x9 VxWorks symbol table, little endian, first entry: [type: function, code address: 0x31313031, symbol address: 0x30313030],,,,,,,,, +436 0x1B4 Intel x86 or x64 microcode, pf_mask 0x10, 0000-00-00, size 22675456 +634 0x27A Intel x86 or x64 microcode, sig 0x5a203200, pf_mask 0x00, 2A00-00-00, rev 0x25a0000, size 2048 +663 0x297 Intel x86 or x64 microcode, pf_mask 0x15a0200, 0000-00-06, size 998656 +848 0x350 Intel x86 or x64 microcode, pf_mask 0x1000001, FFEE-00-00, rev 0x3c0000, size 5 +904 0x388 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x10000, size 2048 +910 0x38E Intel x86 or x64 microcode, sig 0x00000100, pf_mask 0x00, 0000-00-00, size 2048 +926 0x39E Intel x86 or x64 microcode, sig 0x01000000, pf_mask 0x10000, 0000-00-00, rev 0x10000, size 65536 +932 0x3A4 Intel x86 or x64 microcode, pf_mask 0x00, 0100-00-00, size 2048 +941 0x3AD Intel x86 or x64 microcode, sig 0x00190000, pf_mask 0x00, 0000-01-00, rev 0x3000000, size 19660800 +963 0x3C3 Intel x86 or x64 microcode, sig 0x0000012c, pf_mask 0x1010000, 0000-00-00, size 2617246810 +976 0x3D0 Intel x86 or x64 microcode, sig 0x00010100, pf_mask 0x10400000, 0000-00-00, size 1023410176 +990 0x3DE Intel x86 or x64 microcode, sig 0x025a1040, pf_mask 0x00, 029C-00-00, rev 0x45a00, size 4263244 +1149 0x47D Intel x86 or x64 microcode, pf_mask 0x40000000, 0000-40-00, rev 0x0001, size 1073741824 +1153 0x481 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 2048 +1217 0x4C1 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x01, 0000-00-00, rev 0x40000000, size 1 +1241 0x4D9 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x32, 0001-00-00, rev 0x40000000, size 2048 +1249 0x4E1 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 1073741824 +1285 0x505 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x32, 000A-00-00, rev 0x40000000, size 1073741824 +1302 0x516 Intel x86 or x64 microcode, pf_mask 0x1400000, 0000-01-00, rev 0x32400000, size 4194304 +1313 0x521 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x00, 0000-00-00, rev 0x40000000, size 1 +1329 0x531 Intel x86 or x64 microcode, sig 0x40000000, pf_mask 0x09, 0000-00-00, rev 0x40000000, size 1056964608 +1345 0x541 Intel x86 or x64 microcode, sig 0x3a00015a, pf_mask 0x100, 0009-00-00, rev 0x0006, size 256 +1366 0x556 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x01, 0040-00-00, rev 0x0001, size 1 +1370 0x55A Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x7f, 0001-00-00, rev 0x0040, size 400 +1378 0x562 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x190, 00C8-00-00, rev 0x0001, size 1 +1382 0x566 Intel x86 or x64 microcode, sig 0x0000007f, pf_mask 0x00, 0001-00-00, rev 0x00c8, size 127 +1390 0x56E Intel x86 or x64 microcode, sig 0x00000190, pf_mask 0x7f, 0001-00-00, rev 0x007f, size 1275069018 +1398 0x576 Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x4c00025a, 0000-00-00, rev 0x0190, size 16842768 +1403 0x57B Intel x86 or x64 microcode, pf_mask 0x10410000, 0000-7F-00, rev 0x1000000, size 1677747200 +1410 0x582 Intel x86 or x64 microcode, sig 0x4c00025a, pf_mask 0x640000, 0000-00-00, rev 0x007f, size 393216 +1471 0x5BF Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 22675558 +1636 0x664 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 56229953 +1688 0x698 Intel x86 or x64 microcode, sig 0xe0000000, pf_mask 0x25a3f, 0000-00-00, size 16785534 +1735 0x6C7 Intel x86 or x64 microcode, sig 0x20490000, pf_mask 0x1f4, 0002-00-16, rev 0x5a010000, size 2048 +1760 0x6E0 Intel x86 or x64 microcode, sig 0x00710004, pf_mask 0x00, 0000-5A-00, size 2048 +1800 0x708 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x0001, size 4 +1804 0x70C Intel x86 or x64 microcode, sig 0x00000001, pf_mask 0x00, 0000-00-00, size 4 +1816 0x718 Intel x86 or x64 microcode, pf_mask 0x30001, 0000-00-00, rev 0x0001, size 2 +1820 0x71C Intel x86 or x64 microcode, sig 0x00000004, pf_mask 0x00, 0000-00-00, size 3 +2051 0x803 Intel x86 or x64 microcode, pf_mask 0x3d0002, 8010-00-01, size 257 +2061 0x80D Intel x86 or x64 microcode, sig 0x00025a01, pf_mask 0x00, 0101-01-00, rev 0x20000, size 2048 +2084 0x824 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x1010000, size 2048 +2091 0x82B Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 2048 +2152 0x868 Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, rev 0x1000000, size 2048 +2159 0x86F Intel x86 or x64 microcode, pf_mask 0x00, 0000-00-00, size 2048 +2225 0x8B1 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 340848 blocks, 0x532 pages per block, 0x616e5300 bytes per page +2234 0x8BA EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341104 blocks, 0x533 pages per block, 0x616e5300 bytes per page +2243 0x8C3 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341360 blocks, 0x534 pages per block, 0x616e5300 bytes per page +2252 0x8CC EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341616 blocks, 0x535 pages per block, 0x616e5300 bytes per page +2261 0x8D5 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 341872 blocks, 0x536 pages per block, 0x616e5300 bytes per page +2270 0x8DE EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 342128 blocks, 0x537 pages per block, 0x616e5300 bytes per page +2279 0x8E7 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 407920 blocks, 0x538 pages per block, 0x616e5300 bytes per page +2288 0x8F0 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 103821680 blocks, 0x639 pages per block, 0x616e5300 bytes per page +2297 0x8F9 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 825323617 blocks, 0x63031 pages per block, 0x6e530000 bytes per page +2306 0x902 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6313170 pages per block, 0x53000000 bytes per page +2316 0x90C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6323170 pages per block, 0x53000000 bytes per page +2326 0x916 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6333170 pages per block, 0x53000000 bytes per page +2336 0x920 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6343170 pages per block, 0x53000000 bytes per page +2346 0x92A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6353170 pages per block, 0x53000000 bytes per page +2356 0x934 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6363170 pages per block, 0x53000000 bytes per page +2366 0x93E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6373170 pages per block, 0x53000000 bytes per page +2376 0x948 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 829448558 blocks, 0x6383170 pages per block, 0x53000000 bytes per page +2386 0x952 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6393170 pages per block, 0x53000000 bytes per page +2396 0x95C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6303270 pages per block, 0x53000000 bytes per page +2406 0x966 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6313270 pages per block, 0x53000000 bytes per page +2416 0x970 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6323270 pages per block, 0x53000000 bytes per page +2426 0x97A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6333270 pages per block, 0x53000000 bytes per page +2436 0x984 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6343270 pages per block, 0x53000000 bytes per page +2446 0x98E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6353270 pages per block, 0x53000000 bytes per page +2456 0x998 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6363270 pages per block, 0x53000000 bytes per page +2466 0x9A2 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6373270 pages per block, 0x53000000 bytes per page +2476 0x9AC EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 846225774 blocks, 0x6383270 pages per block, 0x53000000 bytes per page +2486 0x9B6 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6393270 pages per block, 0x53000000 bytes per page +2496 0x9C0 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6303370 pages per block, 0x53000000 bytes per page +2506 0x9CA EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6313370 pages per block, 0x53000000 bytes per page +2516 0x9D4 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6323370 pages per block, 0x53000000 bytes per page +2526 0x9DE EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6333370 pages per block, 0x53000000 bytes per page +2536 0x9E8 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6343370 pages per block, 0x53000000 bytes per page +2546 0x9F2 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6353370 pages per block, 0x53000000 bytes per page +2556 0x9FC EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6363370 pages per block, 0x53000000 bytes per page +2566 0xA06 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6373370 pages per block, 0x53000000 bytes per page +2576 0xA10 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 863002990 blocks, 0x6383370 pages per block, 0x53000000 bytes per page +2586 0xA1A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6393370 pages per block, 0x53000000 bytes per page +2596 0xA24 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6303470 pages per block, 0x53000000 bytes per page +2606 0xA2E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6313470 pages per block, 0x53000000 bytes per page +2616 0xA38 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6323470 pages per block, 0x53000000 bytes per page +2626 0xA42 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6333470 pages per block, 0x53000000 bytes per page +2636 0xA4C EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6343470 pages per block, 0x53000000 bytes per page +2646 0xA56 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6353470 pages per block, 0x53000000 bytes per page +2656 0xA60 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6363470 pages per block, 0x53000000 bytes per page +2666 0xA6A EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 879780206 blocks, 0x6373470 pages per block, 0x53000000 bytes per page +2676 0xA74 EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 542507008 blocks, 0x5a383470 pages per block, 0x2b0006 bytes per page +2686 0xA7E EFS2 Qualcomm filesystem super block, little endian, , NOR version 0x616e, 67108864 blocks, 0x12056 pages per block, 0x0 bytes per page +2704 0xA90 Intel x86 or x64 microcode, sig 0x00000200, pf_mask 0x00, 0400-00-00, size 16777216 +2739 0xAB3 Intel x86 or x64 microcode, sig 0x03202400, pf_mask 0x5b, 6A00-00-00, rev 0x65a0050, size 218103808 +2872 0xB38 Intel x86 or x64 microcode, sig 0x0000000d, pf_mask 0x50b09, 0000-01-00, rev 0x0101, size 41 +2877 0xB3D Intel x86 or x64 microcode, sig 0x030a0201, pf_mask 0x2900035a, 0000-00-00, rev 0xd010000, size 288 +2910 0xB5E Intel x86 or x64 microcode, sig 0x00000120, pf_mask 0xfbdc0002, 0000-7A-00, rev 0x1c00025a, size 16777215 +2923 0xB6B Intel x86 or x64 microcode, sig 0xfffbdc00, pf_mask 0x45a0000, 0241-02-00, rev 0x0001, size 119557376 +2927 0xB6F Intel x86 or x64 microcode, sig 0xffff00ff, pf_mask 0x2a00, DC00-FF-FB, rev 0x2000241, size 16777216 +2962 0xB92 Intel x86 or x64 microcode, sig 0x00000100, pf_mask 0x3a343200, 0100-14-01, size 808466992 +2975 0xB9F Intel x86 or x64 microcode, sig 0x303a3432, pf_mask 0x60001, 000B-00-00, rev 0x0007, size 2048 +3154 0xC52 Intel x86 or x64 microcode, sig 0x000a0410, pf_mask 0x63696e6f, 0000-17-00, rev 0x3f00055a, size 1181051984 +3196 0xC7C Intel x86 or x64 microcode, sig 0x6976612e, pf_mask 0x322e616c, 6300-6D-6F, rev 0x1700, size 1426063706 +3272 0xCC8 Intel x86 or x64 microcode, sig 0x4fce34d4, pf_mask 0x00, 6900-43-BA, rev 0x2a00, size 88576 +3363 0xD23 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x424, 0101-00-00, rev 0x1010100, size 2048 +3372 0xD2C Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1342178409 +3423 0xD5F Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40426, 0101-00-00, rev 0x1010100, size 2048 +3432 0xD68 Intel x86 or x64 microcode, sig 0x26260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3483 0xD9B Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40424, 0101-00-00, rev 0x1010100, size 2048 +3492 0xDA4 Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 4600-00-00, rev 0x65a0000, size 2614349582 +3560 0xDE8 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40425, 0101-00-00, rev 0x1010100, size 2048 +3569 0xDF1 Intel x86 or x64 microcode, sig 0x25260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 416562889 +3620 0xE24 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b4040b, 0101-00-00, rev 0x1010100, size 2048 +3629 0xE2D Intel x86 or x64 microcode, sig 0x0b260000, pf_mask 0x2a000000, 4100-00-00, rev 0x65a0000, size 2027085277 +3692 0xE6C Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980425, 0101-00-00, rev 0x1010100, size 2048 +3701 0xE75 Intel x86 or x64 microcode, sig 0x25260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3752 0xEA8 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x75b40427, 0101-00-00, rev 0x1010100, size 2048 +3761 0xEB1 Intel x86 or x64 microcode, sig 0x27260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3812 0xEE4 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980427, 0101-00-00, rev 0x1010100, size 2048 +3821 0xEED Intel x86 or x64 microcode, sig 0x27260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3872 0xF20 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980426, 0101-00-00, rev 0x1010100, size 2048 +3881 0xF29 Intel x86 or x64 microcode, sig 0x26260000, pf_mask 0x2a000000, 3500-00-00, rev 0x65a0000, size 1188286210 +3932 0xF5C Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x1980424, 0101-00-00, rev 0x1010100, size 2048 +3941 0xF65 Intel x86 or x64 microcode, sig 0x24260000, pf_mask 0x2a000000, 4600-00-00, rev 0x65a0000, size 2614349582 +4009 0xFA9 Intel x86 or x64 microcode, sig 0x5a000000, pf_mask 0x198040b, 0101-00-00, rev 0x1010100, size 2048 +4018 0xFB2 Intel x86 or x64 microcode, sig 0x0b260000, pf_mask 0x2a000000, 4100-00-00, rev 0x65a0000, size 500421004 +4081 0xFF1 Intel x86 or x64 microcode, sig 0x0e000000, pf_mask 0x57a64354, 0101-00-00, rev 0x1010100, size 1414812756 +4090 0xFFA Intel x86 or x64 microcode, sig 0x54725454, pf_mask 0x7e545454, 6754-54-54, rev 0x520e0000, size 143105928 +7643 0x1DDB ESP Image flash size: 32MB, entry address: 0x19545454, +8772 0x2244 ESP Image entry address: 0x8ba8a8a8, +8854 0x2296 ESP Image entry address: 0xa8a8a9e4, +8936 0x22E8 ESP Image entry address: 0xa8a8a9fa, +9463 0x24F7 ESP Image entry address: 0xcddcc9c5, +9550 0x254E ESP Image entry address: 0xcddcc9c5, +9637 0x25A5 ESP Image entry address: 0xcddcc9c5, +9757 0x261D ESP Image entry address: 0xa8a8a8a8, +9816 0x2658 ESP Image entry address: 0xa8a0a5cd, +9877 0x2695 ESP Image entry address: 0xa8a0a5cd, +9938 0x26D2 ESP Image entry address: 0xa8a0a5cd, +9999 0x270F ESP Image entry address: 0xa8a0a5cd, +10156 0x27AC ESP Image flash speed: 20MHz, entry address: 0xa8aea8a9, +10234 0x27FA ESP Image flash speed: 20MHz, entry address: 0xa8aea8a9, +10272 0x2820 ESP Image entry address: 0xa8aa9a85, +10362 0x287A ESP Image flash speed: 20MHz, entry address: 0xa8a3a5cd, +10377 0x2889 ESP Image entry address: 0xa9a99a85, +10426 0x28BA ESP Image flash speed: 20MHz, entry address: 0xa8a3a5cd, +10441 0x28C9 ESP Image entry address: 0xa9a99a85, +10490 0x28FA ESP Image flash speed: 20MHz, entry address: 0xa8a3a5cd, +10505 0x2909 ESP Image entry address: 0xa9a99a85, +10554 0x293A ESP Image flash speed: 20MHz, entry address: 0xa8a3a5cd, +10569 0x2949 ESP Image entry address: 0xa9a99a85, +10633 0x2989 ESP Image entry address: 0xa9a99a85, +10677 0x29B5 ESP Image entry address: 0xa8a8a8a9, +10758 0x2A06 ESP Image entry address: 0xa8a8a8a9, +10839 0x2A57 ESP Image entry address: 0xa8aa9c85, +10929 0x2AB1 ESP Image entry address: 0xa8a3a5cd, +10944 0x2AC0 ESP Image entry address: 0xa9a99c85, +10993 0x2AF1 ESP Image entry address: 0xa8a3a5cd, +11008 0x2B00 ESP Image entry address: 0xa9a99c85, +11057 0x2B31 ESP Image entry address: 0xa8a3a5cd, +11072 0x2B40 ESP Image entry address: 0xa9a99c85, +11121 0x2B71 ESP Image entry address: 0xa8a3a5cd, +11136 0x2B80 ESP Image entry address: 0xa9a99c85, +11200 0x2BC0 ESP Image entry address: 0xa9a99c85, +11244 0x2BEC ESP Image entry address: 0xa8a8a8a9, +11325 0x2C3D ESP Image entry address: 0xa8a8a8a9, +11491 0x2CE3 ESP Image entry address: 0xa8aea5cd, +11550 0x2D1E ESP Image entry address: 0xa8aea5cd, +11609 0x2D59 ESP Image entry address: 0xa8aea5cd, +11668 0x2D94 ESP Image entry address: 0xa8aea5cd, +12266 0x2FEA ESP Image flash speed: 26MHz, entry address: 0xdacdfe88, +13007 0x32CF BFF volume entry, compressed, file name: "ûüüü±³²Ü°Ó®ýýüüüüýýýýýüüüüü¦úü½üüüüÚ÷øH‰òֈüüüüÖüüüÐ!!.„ w˜ïüüü¾‰•ˆÑ•’ܳ‰ˆŒ‰ˆÜÍÑÎýýüüüüýýýýýüüüüü¦úüÉüüüüÚÙødý[WìCüüüüÖüüüñþ3/" +16247 0x3F77 ESP Image entry address: 0xfcfd0303, +16309 0x3FB5 ESP Image entry address: 0xfcfcfcfd, +20607 0x507F ESP Image flash speed: 26MHz, entry address: 0xa8a4a6d6, +20639 0x509F ESP Image flash speed: 26MHz, entry address: 0xa8a4a6d6, +24631 0x6037 ESP Image entry address: 0xf8f8f8f8, +24671 0x605F ESP Image entry address: 0xf830f8f8, +24707 0x6083 ESP Image entry address: 0xf8dff8f8, +24743 0x60A7 ESP Image entry address: 0xf884f8f8, +25712 0x6470 ESP Image entry address: 0xf8b5f8f8, +26031 0x65AF ESP Image entry address: 0xf8d5f8f8, +26675 0x6833 ESP Image entry address: 0xf8d5f8f8, +27778 0x6C82 ESP Image entry address: 0xf8f1dbf3, +27802 0x6C9A ESP Image entry address: 0xf8f1dbf3, +27826 0x6CB2 ESP Image entry address: 0xf8f1dbf3, +27850 0x6CCA ESP Image entry address: 0xf8f1dbf3, +27874 0x6CE2 ESP Image entry address: 0xf8f1dbf3, +27898 0x6CFA ESP Image entry address: 0xf8f1dbf3, +27922 0x6D12 ESP Image entry address: 0xf8f1dbf3, +27946 0x6D2A ESP Image entry address: 0xf8f1dbf3, +27970 0x6D42 ESP Image entry address: 0xf8f1dbf3, +27994 0x6D5A ESP Image entry address: 0xf8f1dbf3, +28018 0x6D72 ESP Image entry address: 0xf8f1dbf3, +28042 0x6D8A ESP Image entry address: 0xf8f1dbf3, +28066 0x6DA2 ESP Image entry address: 0xf8f1dbf3, +28090 0x6DBA ESP Image entry address: 0xf8f1dbf3, +28114 0x6DD2 ESP Image entry address: 0xf8f1dbf3, +28138 0x6DEA ESP Image entry address: 0xf8f1dbf3, +28162 0x6E02 ESP Image entry address: 0xf8f1dbf3, +28186 0x6E1A ESP Image entry address: 0xf8f1dbf3, +28210 0x6E32 ESP Image entry address: 0xf8f1dbf3, +28234 0x6E4A ESP Image entry address: 0xf8f1dbf3, +28258 0x6E62 ESP Image entry address: 0xf8f1dbf3, +28282 0x6E7A ESP Image entry address: 0xf8f1dbf3, +28306 0x6E92 ESP Image entry address: 0xf8f1dbf3, +28330 0x6EAA ESP Image entry address: 0xf8f1dbf3, +28354 0x6EC2 ESP Image entry address: 0xf8f1dbf3, +28378 0x6EDA ESP Image entry address: 0xf8f1dbf3, +28402 0x6EF2 ESP Image entry address: 0xf8f1dbf3, +28426 0x6F0A ESP Image entry address: 0xf8f1dbf3, +28450 0x6F22 ESP Image entry address: 0xf8f1dbf3, +28474 0x6F3A ESP Image entry address: 0xf8f1dbf3, +28498 0x6F52 ESP Image entry address: 0xf8f1dbf3, +28522 0x6F6A ESP Image entry address: 0xf8f1dbf3, +28546 0x6F82 ESP Image entry address: 0xf8f1dbf3, +28570 0x6F9A ESP Image entry address: 0xf8f1dbf3, +28594 0x6FB2 ESP Image entry address: 0xf8f1dbf3, +28618 0x6FCA ESP Image entry address: 0xf8f1dbf3, +28642 0x6FE2 ESP Image entry address: 0xf8f1dbf3, +28666 0x6FFA ESP Image entry address: 0x4c45dbf3, +34382 0x864E ESP Image flash speed: 40MHz, entry address: 0xa0a0a0a0, + diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/BpwF/MyLicenses_H_2017/x64/Protect/VS2017/iLok License Manager.pdb b/ptx/edenDev/edenDev/jenkins/full/eden/client/BpwF/MyLicenses_H_2017/x64/Protect/VS2017/iLok License Manager.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/PACEEdenExperienceProxy.pdb b/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/PACEEdenExperienceProxy.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/WrapBootstrap.pdb b/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/WrapBootstrap.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/WrapProxy.pdb b/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/WrapProxy.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/iloktool.pdb b/ptx/edenDev/edenDev/jenkins/full/eden/client/buildProductsWin/Release/x64/VS2017/iloktool.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/@AASStrings.txt b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/@AASStrings.txt new file mode 100644 index 0000000..d4699d2 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/@AASStrings.txt @@ -0,0 +1,23 @@ +Customer ActivationAgentServer + +ActivationAgentServer for socket: + +Manufacturer ID +Ethernet MAC address +hard disk serial number +processor type +IDE controller ID +SCSI host adapter ID +volume serial number +CDROM ID +graphics card ID +V2 IDE controller ID +V2 SCSI host adapter ID +V2 CDROM ID +V2 graphics card ID +V3 BIOS serial number + +Ethernet Built-in +Ethernet USB +Ethernet Unspecified + diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/ActivationAgentServer.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/ActivationAgentServer.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/AuthorizationVerifier.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/AuthorizationVerifier.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/EncryptedBlobArrayUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/EncryptedBlobArrayUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/PaceEden.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/customer/libraries/src/libpacefusion/PaceEden.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/enduser/tools/iloktool/crossplatform/iloktool.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/enduser/tools/iloktool/crossplatform/iloktool.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/liblicenseservicessuport/LsPerEntityMap.h b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/liblicenseservicessuport/LsPerEntityMap.h new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/LogUtils.h b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/LogUtils.h new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/StringUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/StringUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/ThriftUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/inc/libpaceutil/ThriftUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libactivate/MachineIdLsUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libactivate/MachineIdLsUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libauthorize/ClientConnectionOpener.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libauthorize/ClientConnectionOpener.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/BinaryCertifierBase.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/BinaryCertifierBase.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/platform/win/BinaryCertifierWin.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/platform/win/BinaryCertifierWin.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/platform/win/OsSignatureWin.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libbinarydsig/platform/win/OsSignatureWin.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/Ilok.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/Ilok.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/IlokOpener.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/IlokOpener.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/platform/win/libilokwin.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokusb/platform/win/libilokwin.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1Container.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1Container.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1Parser.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1Parser.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1ParserCert.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Asn1ParserCert.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Certifier.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Certifier.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Encryptor.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Encryptor.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Hasher.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Hasher.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/ILokCert.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/ILokCert.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/ILokConduit_ILokUSB.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/ILokConduit_ILokUSB.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok1Commander.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok1Commander.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok1Protocols.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok1Protocols.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok2Commander.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok2Commander.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok2Protocols.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Ilok2Protocols.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/KeyExchanger.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/KeyExchanger.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/LicenseDaemonCert.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/LicenseDaemonCert.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Signer.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libilokutil/Signer.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/ImlActivationServicesHandler.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/ImlActivationServicesHandler.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/ImlActivationServicesManager.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/ImlActivationServicesManager.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/LibimlApi2Min.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/LibimlApi2Min.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/PaceEdenApiAdapter.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libiml/PaceEdenApiAdapter.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureCollector.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureCollector.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureGenerator.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureGenerator.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureVerifier.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSignatureVerifier.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSigningConfigMap.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/DsigSigningConfigMap.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsCachedObjectVectorBase.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsCachedObjectVectorBase.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsObjectCache.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsObjectCache.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsObjectRelationVectorBase.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsObjectRelationVectorBase.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsProxyBase.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservices/LsProxyBase.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservicessupport/LsObjectStoreUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservicessupport/LsObjectStoreUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservicessupport/LsPerEntityMap.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/liblicenseservicessupport/LsPerEntityMap.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/Base64Utils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/Base64Utils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/CheckDihedral.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/CheckDihedral.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/CryptUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/CryptUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/EnvVar.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/EnvVar.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/InstallUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/InstallUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/ProcessUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/ProcessUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/PukkaUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/PukkaUtils.cpp new file mode 100644 index 0000000..0f6a867 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/PukkaUtils.cpp @@ -0,0 +1,3 @@ +#include + +"Pukka code construction requires %u decimal digit groups. You provided %u." \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/Sha1Utils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/Sha1Utils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/StringUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/StringUtils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/ThriftUtils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/ThriftUtils.cpp new file mode 100644 index 0000000..8721e38 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/ThriftUtils.cpp @@ -0,0 +1,7 @@ +#include + +// pace::eden::thrift::activate::ActivationPreferences +// pace::eden::thrift::activate::FrontendResult +// pace::eden::thrift::activate::ServiceIdList_T +// pace::eden::thrift::pub::eAuthState +// en::thrift::activate::Se \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/VerifiedBinaryProtocol.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/VerifiedBinaryProtocol.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/WebRequestBase.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/WebRequestBase.cpp new file mode 100644 index 0000000..4dc342d --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/WebRequestBase.cpp @@ -0,0 +1,3 @@ +#include + +// boost unique_lock doesn't own the mutex \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/fetch.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/fetch.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/filesystem.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/filesystem.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/memorytransport.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/memorytransport.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/miniz.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/miniz.cpp new file mode 100644 index 0000000..bf35eab --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/miniz.cpp @@ -0,0 +1,7921 @@ +#include "miniz.h" +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + + +typedef unsigned char mz_validate_uint16[sizeof(mz_uint16) == 2 ? 1 : -1]; +typedef unsigned char mz_validate_uint32[sizeof(mz_uint32) == 4 ? 1 : -1]; +typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1]; + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* ------------------- zlib-style API's */ + + mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len) + { + mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); + size_t block_len = buf_len % 5552; + if (!ptr) + return MZ_ADLER32_INIT; + while (buf_len) + { + for (i = 0; i + 7 < block_len; i += 8, ptr += 8) + { + s1 += ptr[0], s2 += s1; + s1 += ptr[1], s2 += s1; + s1 += ptr[2], s2 += s1; + s1 += ptr[3], s2 += s1; + s1 += ptr[4], s2 += s1; + s1 += ptr[5], s2 += s1; + s1 += ptr[6], s2 += s1; + s1 += ptr[7], s2 += s1; + } + for (; i < block_len; ++i) + s1 += *ptr++, s2 += s1; + s1 %= 65521U, s2 %= 65521U; + buf_len -= block_len; + block_len = 5552; + } + return (s2 << 16) + s1; + } + +/* 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/ */ +#if 0 + mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) + { + static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, + 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c }; + mz_uint32 crcu32 = (mz_uint32)crc; + if (!ptr) + return MZ_CRC32_INIT; + crcu32 = ~crcu32; + while (buf_len--) + { + mz_uint8 b = *ptr++; + crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)]; + crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)]; + } + return ~crcu32; + } +#elif defined(USE_EXTERNAL_MZCRC) +/* If USE_EXTERNAL_CRC is defined, an external module will export the + * mz_crc32() symbol for us to use, e.g. an SSE-accelerated version. + * Depending on the impl, it may be necessary to ~ the input/output crc values. + */ +mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len); +#else +/* Faster, but larger CPU cache footprint. + */ +mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) +{ + static const mz_uint32 s_crc_table[256] = { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, + 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, + 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, + 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, + 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, + 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, + 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, + 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, + 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, + 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, + 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, + 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, + 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, + 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, + 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, + 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, + 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, + 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, + 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, + 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, + 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, + 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, + 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, + 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, + 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, + 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, + 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, + 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, + 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, + 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, + 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, + 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, + 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D + }; + + mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF; + const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr; + + while (buf_len >= 4) + { + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; + pByte_buf += 4; + buf_len -= 4; + } + + while (buf_len) + { + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; + ++pByte_buf; + --buf_len; + } + + return ~crc32; +} +#endif + + void mz_free(void *p) + { + MZ_FREE(p); + } + + MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, size_t size) + { + (void)opaque, (void)items, (void)size; + return MZ_MALLOC(items * size); + } + MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address) + { + (void)opaque, (void)address; + MZ_FREE(address); + } + MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size) + { + (void)opaque, (void)address, (void)items, (void)size; + return MZ_REALLOC(address, items * size); + } + + const char *mz_version(void) + { + return MZ_VERSION; + } + +#ifndef MINIZ_NO_ZLIB_APIS + +#ifndef MINIZ_NO_DEFLATE_APIS + + int mz_deflateInit(mz_streamp pStream, int level) + { + return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, MZ_DEFAULT_STRATEGY); + } + + int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy) + { + tdefl_compressor *pComp; + mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy); + + if (!pStream) + return MZ_STREAM_ERROR; + if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))) + return MZ_PARAM_ERROR; + + pStream->data_type = 0; + pStream->adler = MZ_ADLER32_INIT; + pStream->msg = NULL; + pStream->reserved = 0; + pStream->total_in = 0; + pStream->total_out = 0; + if (!pStream->zalloc) + pStream->zalloc = miniz_def_alloc_func; + if (!pStream->zfree) + pStream->zfree = miniz_def_free_func; + + pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor)); + if (!pComp) + return MZ_MEM_ERROR; + + pStream->state = (struct mz_internal_state *)pComp; + + if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) + { + mz_deflateEnd(pStream); + return MZ_PARAM_ERROR; + } + + return MZ_OK; + } + + int mz_deflateReset(mz_streamp pStream) + { + if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree)) + return MZ_STREAM_ERROR; + pStream->total_in = pStream->total_out = 0; + tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags); + return MZ_OK; + } + + int mz_deflate(mz_streamp pStream, int flush) + { + size_t in_bytes, out_bytes; + mz_ulong orig_total_in, orig_total_out; + int mz_status = MZ_OK; + + if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out)) + return MZ_STREAM_ERROR; + if (!pStream->avail_out) + return MZ_BUF_ERROR; + + if (flush == MZ_PARTIAL_FLUSH) + flush = MZ_SYNC_FLUSH; + + if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE) + return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; + + orig_total_in = pStream->total_in; + orig_total_out = pStream->total_out; + for (;;) + { + tdefl_status defl_status; + in_bytes = pStream->avail_in; + out_bytes = pStream->avail_out; + + defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush); + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state); + + pStream->next_out += (mz_uint)out_bytes; + pStream->avail_out -= (mz_uint)out_bytes; + pStream->total_out += (mz_uint)out_bytes; + + if (defl_status < 0) + { + mz_status = MZ_STREAM_ERROR; + break; + } + else if (defl_status == TDEFL_STATUS_DONE) + { + mz_status = MZ_STREAM_END; + break; + } + else if (!pStream->avail_out) + break; + else if ((!pStream->avail_in) && (flush != MZ_FINISH)) + { + if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out)) + break; + return MZ_BUF_ERROR; /* Can't make forward progress without some input. + */ + } + } + return mz_status; + } + + int mz_deflateEnd(mz_streamp pStream) + { + if (!pStream) + return MZ_STREAM_ERROR; + if (pStream->state) + { + pStream->zfree(pStream->opaque, pStream->state); + pStream->state = NULL; + } + return MZ_OK; + } + + mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len) + { + (void)pStream; + /* 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.) */ + return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5); + } + + int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level) + { + int status; + mz_stream stream; + memset(&stream, 0, sizeof(stream)); + + /* In case mz_ulong is 64-bits (argh I hate longs). */ + if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU) + return MZ_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (mz_uint32)source_len; + stream.next_out = pDest; + stream.avail_out = (mz_uint32)*pDest_len; + + status = mz_deflateInit(&stream, level); + if (status != MZ_OK) + return status; + + status = mz_deflate(&stream, MZ_FINISH); + if (status != MZ_STREAM_END) + { + mz_deflateEnd(&stream); + return (status == MZ_OK) ? MZ_BUF_ERROR : status; + } + + *pDest_len = stream.total_out; + return mz_deflateEnd(&stream); + } + + int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len) + { + return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION); + } + + mz_ulong mz_compressBound(mz_ulong source_len) + { + return mz_deflateBound(NULL, source_len); + } + +#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/ + +#ifndef MINIZ_NO_INFLATE_APIS + + typedef struct + { + tinfl_decompressor m_decomp; + mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed; + int m_window_bits; + mz_uint8 m_dict[TINFL_LZ_DICT_SIZE]; + tinfl_status m_last_status; + } inflate_state; + + int mz_inflateInit2(mz_streamp pStream, int window_bits) + { + inflate_state *pDecomp; + if (!pStream) + return MZ_STREAM_ERROR; + if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)) + return MZ_PARAM_ERROR; + + pStream->data_type = 0; + pStream->adler = 0; + pStream->msg = NULL; + pStream->total_in = 0; + pStream->total_out = 0; + pStream->reserved = 0; + if (!pStream->zalloc) + pStream->zalloc = miniz_def_alloc_func; + if (!pStream->zfree) + pStream->zfree = miniz_def_free_func; + + pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state)); + if (!pDecomp) + return MZ_MEM_ERROR; + + pStream->state = (struct mz_internal_state *)pDecomp; + + tinfl_init(&pDecomp->m_decomp); + pDecomp->m_dict_ofs = 0; + pDecomp->m_dict_avail = 0; + pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; + pDecomp->m_first_call = 1; + pDecomp->m_has_flushed = 0; + pDecomp->m_window_bits = window_bits; + + return MZ_OK; + } + + int mz_inflateInit(mz_streamp pStream) + { + return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS); + } + + int mz_inflateReset(mz_streamp pStream) + { + inflate_state *pDecomp; + if (!pStream) + return MZ_STREAM_ERROR; + + pStream->data_type = 0; + pStream->adler = 0; + pStream->msg = NULL; + pStream->total_in = 0; + pStream->total_out = 0; + pStream->reserved = 0; + + pDecomp = (inflate_state *)pStream->state; + + tinfl_init(&pDecomp->m_decomp); + pDecomp->m_dict_ofs = 0; + pDecomp->m_dict_avail = 0; + pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; + pDecomp->m_first_call = 1; + pDecomp->m_has_flushed = 0; + /* pDecomp->m_window_bits = window_bits */; + + return MZ_OK; + } + + int mz_inflate(mz_streamp pStream, int flush) + { + inflate_state *pState; + mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; + size_t in_bytes, out_bytes, orig_avail_in; + tinfl_status status; + + if ((!pStream) || (!pStream->state)) + return MZ_STREAM_ERROR; + if (flush == MZ_PARTIAL_FLUSH) + flush = MZ_SYNC_FLUSH; + if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) + return MZ_STREAM_ERROR; + + pState = (inflate_state *)pStream->state; + if (pState->m_window_bits > 0) + decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; + orig_avail_in = pStream->avail_in; + + first_call = pState->m_first_call; + pState->m_first_call = 0; + if (pState->m_last_status < 0) + return MZ_DATA_ERROR; + + if (pState->m_has_flushed && (flush != MZ_FINISH)) + return MZ_STREAM_ERROR; + pState->m_has_flushed |= (flush == MZ_FINISH); + + if ((flush == MZ_FINISH) && (first_call)) + { + /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */ + decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF; + in_bytes = pStream->avail_in; + out_bytes = pStream->avail_out; + status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags); + pState->m_last_status = status; + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tinfl_get_adler32(&pState->m_decomp); + pStream->next_out += (mz_uint)out_bytes; + pStream->avail_out -= (mz_uint)out_bytes; + pStream->total_out += (mz_uint)out_bytes; + + if (status < 0) + return MZ_DATA_ERROR; + else if (status != TINFL_STATUS_DONE) + { + pState->m_last_status = TINFL_STATUS_FAILED; + return MZ_BUF_ERROR; + } + return MZ_STREAM_END; + } + /* flush != MZ_FINISH then we must assume there's more input. */ + if (flush != MZ_FINISH) + decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; + + if (pState->m_dict_avail) + { + n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); + memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); + pStream->next_out += n; + pStream->avail_out -= n; + pStream->total_out += n; + pState->m_dict_avail -= n; + pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); + return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; + } + + for (;;) + { + in_bytes = pStream->avail_in; + out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; + + 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); + pState->m_last_status = status; + + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tinfl_get_adler32(&pState->m_decomp); + + pState->m_dict_avail = (mz_uint)out_bytes; + + n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); + memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); + pStream->next_out += n; + pStream->avail_out -= n; + pStream->total_out += n; + pState->m_dict_avail -= n; + pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); + + if (status < 0) + return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */ + else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) + return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */ + else if (flush == MZ_FINISH) + { + /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */ + if (status == TINFL_STATUS_DONE) + return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; + /* 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. */ + else if (!pStream->avail_out) + return MZ_BUF_ERROR; + } + else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail)) + break; + } + + return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK; + } + + int mz_inflateEnd(mz_streamp pStream) + { + if (!pStream) + return MZ_STREAM_ERROR; + if (pStream->state) + { + pStream->zfree(pStream->opaque, pStream->state); + pStream->state = NULL; + } + return MZ_OK; + } + int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len) + { + mz_stream stream; + int status; + memset(&stream, 0, sizeof(stream)); + + /* In case mz_ulong is 64-bits (argh I hate longs). */ + if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU) + return MZ_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (mz_uint32)*pSource_len; + stream.next_out = pDest; + stream.avail_out = (mz_uint32)*pDest_len; + + status = mz_inflateInit(&stream); + if (status != MZ_OK) + return status; + + status = mz_inflate(&stream, MZ_FINISH); + *pSource_len = *pSource_len - stream.avail_in; + if (status != MZ_STREAM_END) + { + mz_inflateEnd(&stream); + return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status; + } + *pDest_len = stream.total_out; + + return mz_inflateEnd(&stream); + } + + int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len) + { + return mz_uncompress2(pDest, pDest_len, pSource, &source_len); + } + +#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/ + + const char *mz_error(int err) + { + static struct + { + int m_err; + const char *m_pDesc; + } s_error_descs[] = { + { 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" } + }; + mz_uint i; + for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) + if (s_error_descs[i].m_err == err) + return s_error_descs[i].m_pDesc; + return NULL; + } + +#endif /*MINIZ_NO_ZLIB_APIS */ + +#ifdef __cplusplus +} +#endif + +/* + This is free and unencumbered software released into the public domain. + + Anyone is free to copy, modify, publish, use, compile, sell, or + distribute this software, either in source code form or as a compiled + binary, for any purpose, commercial or non-commercial, and by any + means. + + In jurisdictions that recognize copyright laws, the author or authors + of this software dedicate any and all copyright interest in the + software to the public domain. We make this dedication for the benefit + of the public at large and to the detriment of our heirs and + successors. We intend this dedication to be an overt act of + relinquishment in perpetuity of all present and future rights to this + software under copyright law. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + For more information, please refer to +*/ +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + + +#ifndef MINIZ_NO_DEFLATE_APIS + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* ------------------- Low-level Compression (independent from all decompression API's) */ + + /* Purposely making these tables static for faster init and thread safety. */ + static const mz_uint16 s_tdefl_len_sym[256] = { + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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 + }; + + static const mz_uint8 s_tdefl_len_extra[256] = { + 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, + 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, + 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, + 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 + }; + + static const mz_uint8 s_tdefl_small_dist_sym[512] = { + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 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 + }; + + static const mz_uint8 s_tdefl_small_dist_extra[512] = { + 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, + 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, + 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, + 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, + 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, + 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, + 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, + 7, 7, 7, 7, 7, 7, 7, 7 + }; + + static const mz_uint8 s_tdefl_large_dist_sym[128] = { + 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, + 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, + 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 + }; + + static const mz_uint8 s_tdefl_large_dist_extra[128] = { + 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, + 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, + 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 + }; + + /* Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted values. */ + typedef struct + { + mz_uint16 m_key, m_sym_index; + } tdefl_sym_freq; + static tdefl_sym_freq *tdefl_radix_sort_syms(mz_uint num_syms, tdefl_sym_freq *pSyms0, tdefl_sym_freq *pSyms1) + { + mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; + tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; + MZ_CLEAR_ARR(hist); + for (i = 0; i < num_syms; i++) + { + mz_uint freq = pSyms0[i].m_key; + hist[freq & 0xFF]++; + hist[256 + ((freq >> 8) & 0xFF)]++; + } + while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) + total_passes--; + for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) + { + const mz_uint32 *pHist = &hist[pass << 8]; + mz_uint offsets[256], cur_ofs = 0; + for (i = 0; i < 256; i++) + { + offsets[i] = cur_ofs; + cur_ofs += pHist[i]; + } + for (i = 0; i < num_syms; i++) + pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = pCur_syms[i]; + { + tdefl_sym_freq *t = pCur_syms; + pCur_syms = pNew_syms; + pNew_syms = t; + } + } + return pCur_syms; + } + + /* tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. */ + static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n) + { + int root, leaf, next, avbl, used, dpth; + if (n == 0) + return; + else if (n == 1) + { + A[0].m_key = 1; + return; + } + A[0].m_key += A[1].m_key; + root = 0; + leaf = 2; + for (next = 1; next < n - 1; next++) + { + if (leaf >= n || A[root].m_key < A[leaf].m_key) + { + A[next].m_key = A[root].m_key; + A[root++].m_key = (mz_uint16)next; + } + else + A[next].m_key = A[leaf++].m_key; + if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) + { + A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); + A[root++].m_key = (mz_uint16)next; + } + else + A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); + } + A[n - 2].m_key = 0; + for (next = n - 3; next >= 0; next--) + A[next].m_key = A[A[next].m_key].m_key + 1; + avbl = 1; + used = dpth = 0; + root = n - 2; + next = n - 1; + while (avbl > 0) + { + while (root >= 0 && (int)A[root].m_key == dpth) + { + used++; + root--; + } + while (avbl > used) + { + A[next--].m_key = (mz_uint16)(dpth); + avbl--; + } + avbl = 2 * used; + dpth++; + used = 0; + } + } + + /* Limits canonical Huffman code table's max code size. */ + enum + { + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 + }; + static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size) + { + int i; + mz_uint32 total = 0; + if (code_list_len <= 1) + return; + for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) + pNum_codes[max_code_size] += pNum_codes[i]; + for (i = max_code_size; i > 0; i--) + total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); + while (total != (1UL << max_code_size)) + { + pNum_codes[max_code_size]--; + for (i = max_code_size - 1; i > 0; i--) + if (pNum_codes[i]) + { + pNum_codes[i]--; + pNum_codes[i + 1] += 2; + break; + } + total--; + } + } + + static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, int table_len, int code_size_limit, int static_table) + { + int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; + mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; + MZ_CLEAR_ARR(num_codes); + if (static_table) + { + for (i = 0; i < table_len; i++) + num_codes[d->m_huff_code_sizes[table_num][i]]++; + } + else + { + tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], *pSyms; + int num_used_syms = 0; + const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; + for (i = 0; i < table_len; i++) + if (pSym_count[i]) + { + syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; + syms0[num_used_syms++].m_sym_index = (mz_uint16)i; + } + + pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); + tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); + + for (i = 0; i < num_used_syms; i++) + num_codes[pSyms[i].m_key]++; + + tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, code_size_limit); + + MZ_CLEAR_ARR(d->m_huff_code_sizes[table_num]); + MZ_CLEAR_ARR(d->m_huff_codes[table_num]); + for (i = 1, j = num_used_syms; i <= code_size_limit; i++) + for (l = num_codes[i]; l > 0; l--) + d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); + } + + next_code[1] = 0; + for (j = 0, i = 2; i <= code_size_limit; i++) + next_code[i] = j = ((j + num_codes[i - 1]) << 1); + + for (i = 0; i < table_len; i++) + { + mz_uint rev_code = 0, code, code_size; + if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) + continue; + code = next_code[code_size]++; + for (l = code_size; l > 0; l--, code >>= 1) + rev_code = (rev_code << 1) | (code & 1); + d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; + } + } + +#define TDEFL_PUT_BITS(b, l) \ + do \ + { \ + mz_uint bits = b; \ + mz_uint len = l; \ + MZ_ASSERT(bits <= ((1U << len) - 1U)); \ + d->m_bit_buffer |= (bits << d->m_bits_in); \ + d->m_bits_in += len; \ + while (d->m_bits_in >= 8) \ + { \ + if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ + *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ + d->m_bit_buffer >>= 8; \ + d->m_bits_in -= 8; \ + } \ + } \ + MZ_MACRO_END + +#define TDEFL_RLE_PREV_CODE_SIZE() \ + { \ + if (rle_repeat_count) \ + { \ + if (rle_repeat_count < 3) \ + { \ + d->m_huff_count[2][prev_code_size] = (mz_uint16)(d->m_huff_count[2][prev_code_size] + rle_repeat_count); \ + while (rle_repeat_count--) \ + packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ + } \ + else \ + { \ + d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 16; \ + packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_repeat_count - 3); \ + } \ + rle_repeat_count = 0; \ + } \ + } + +#define TDEFL_RLE_ZERO_CODE_SIZE() \ + { \ + if (rle_z_count) \ + { \ + if (rle_z_count < 3) \ + { \ + d->m_huff_count[2][0] = (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ + while (rle_z_count--) \ + packed_code_sizes[num_packed_code_sizes++] = 0; \ + } \ + else if (rle_z_count <= 10) \ + { \ + d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 17; \ + packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 3); \ + } \ + else \ + { \ + d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 18; \ + packed_code_sizes[num_packed_code_sizes++] = (mz_uint8)(rle_z_count - 11); \ + } \ + rle_z_count = 0; \ + } \ + } + + 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 }; + + static void tdefl_start_dynamic_block(tdefl_compressor *d) + { + int num_lit_codes, num_dist_codes, num_bit_lengths; + mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, rle_repeat_count, packed_code_sizes_index; + 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; + + d->m_huff_count[0][256] = 1; + + tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); + tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); + + for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) + if (d->m_huff_code_sizes[0][num_lit_codes - 1]) + break; + for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) + if (d->m_huff_code_sizes[1][num_dist_codes - 1]) + break; + + memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); + memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], num_dist_codes); + total_code_sizes_to_pack = num_lit_codes + num_dist_codes; + num_packed_code_sizes = 0; + rle_z_count = 0; + rle_repeat_count = 0; + + memset(&d->m_huff_count[2][0], 0, sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); + for (i = 0; i < total_code_sizes_to_pack; i++) + { + mz_uint8 code_size = code_sizes_to_pack[i]; + if (!code_size) + { + TDEFL_RLE_PREV_CODE_SIZE(); + if (++rle_z_count == 138) + { + TDEFL_RLE_ZERO_CODE_SIZE(); + } + } + else + { + TDEFL_RLE_ZERO_CODE_SIZE(); + if (code_size != prev_code_size) + { + TDEFL_RLE_PREV_CODE_SIZE(); + d->m_huff_count[2][code_size] = (mz_uint16)(d->m_huff_count[2][code_size] + 1); + packed_code_sizes[num_packed_code_sizes++] = code_size; + } + else if (++rle_repeat_count == 6) + { + TDEFL_RLE_PREV_CODE_SIZE(); + } + } + prev_code_size = code_size; + } + if (rle_repeat_count) + { + TDEFL_RLE_PREV_CODE_SIZE(); + } + else + { + TDEFL_RLE_ZERO_CODE_SIZE(); + } + + tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); + + TDEFL_PUT_BITS(2, 2); + + TDEFL_PUT_BITS(num_lit_codes - 257, 5); + TDEFL_PUT_BITS(num_dist_codes - 1, 5); + + for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) + if (d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) + break; + num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); + TDEFL_PUT_BITS(num_bit_lengths - 4, 4); + for (i = 0; (int)i < num_bit_lengths; i++) + TDEFL_PUT_BITS(d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); + + for (packed_code_sizes_index = 0; packed_code_sizes_index < num_packed_code_sizes;) + { + mz_uint code = packed_code_sizes[packed_code_sizes_index++]; + MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); + TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); + if (code >= 16) + TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], "\02\03\07"[code - 16]); + } + } + + static void tdefl_start_static_block(tdefl_compressor *d) + { + mz_uint i; + mz_uint8 *p = &d->m_huff_code_sizes[0][0]; + + for (i = 0; i <= 143; ++i) + *p++ = 8; + for (; i <= 255; ++i) + *p++ = 9; + for (; i <= 279; ++i) + *p++ = 7; + for (; i <= 287; ++i) + *p++ = 8; + + memset(d->m_huff_code_sizes[1], 5, 32); + + tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE); + tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE); + + TDEFL_PUT_BITS(1, 2); + } + + static const mz_uint mz_bitmasks[17] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF }; + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS + static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) + { + mz_uint flags; + mz_uint8 *pLZ_codes; + mz_uint8 *pOutput_buf = d->m_pOutput_buf; + mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf; + mz_uint64 bit_buffer = d->m_bit_buffer; + mz_uint bits_in = d->m_bits_in; + +#define TDEFL_PUT_BITS_FAST(b, l) \ + { \ + bit_buffer |= (((mz_uint64)(b)) << bits_in); \ + bits_in += (l); \ + } + + flags = 1; + for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; flags >>= 1) + { + if (flags == 1) + flags = *pLZ_codes++ | 0x100; + + if (flags & 1) + { + mz_uint s0, s1, n0, n1, sym, num_extra_bits; + mz_uint match_len = pLZ_codes[0]; + mz_uint match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); + pLZ_codes += 3; + + MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + 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]]); + TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); + + /* This sequence coaxes MSVC into using cmov's vs. jmp's. */ + s0 = s_tdefl_small_dist_sym[match_dist & 511]; + n0 = s_tdefl_small_dist_extra[match_dist & 511]; + s1 = s_tdefl_large_dist_sym[match_dist >> 8]; + n1 = s_tdefl_large_dist_extra[match_dist >> 8]; + sym = (match_dist < 512) ? s0 : s1; + num_extra_bits = (match_dist < 512) ? n0 : n1; + + MZ_ASSERT(d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); + } + else + { + mz_uint lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); + + if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end)) + { + flags >>= 1; + lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); + + if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end)) + { + flags >>= 1; + lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); + } + } + } + + if (pOutput_buf >= d->m_pOutput_buf_end) + return MZ_FALSE; + + memcpy(pOutput_buf, &bit_buffer, sizeof(mz_uint64)); + pOutput_buf += (bits_in >> 3); + bit_buffer >>= (bits_in & ~7); + bits_in &= 7; + } + +#undef TDEFL_PUT_BITS_FAST + + d->m_pOutput_buf = pOutput_buf; + d->m_bits_in = 0; + d->m_bit_buffer = 0; + + while (bits_in) + { + mz_uint32 n = MZ_MIN(bits_in, 16); + TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n); + bit_buffer >>= n; + bits_in -= n; + } + + TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); + + return (d->m_pOutput_buf < d->m_pOutput_buf_end); + } +#else +static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) +{ + mz_uint flags; + mz_uint8 *pLZ_codes; + + flags = 1; + for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; flags >>= 1) + { + if (flags == 1) + flags = *pLZ_codes++ | 0x100; + if (flags & 1) + { + mz_uint sym, num_extra_bits; + mz_uint match_len = pLZ_codes[0], match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); + pLZ_codes += 3; + + MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + 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]]); + TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], s_tdefl_len_extra[match_len]); + + if (match_dist < 512) + { + sym = s_tdefl_small_dist_sym[match_dist]; + num_extra_bits = s_tdefl_small_dist_extra[match_dist]; + } + else + { + sym = s_tdefl_large_dist_sym[match_dist >> 8]; + num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8]; + } + MZ_ASSERT(d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); + } + else + { + mz_uint lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); + } + } + + TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); + + return (d->m_pOutput_buf < d->m_pOutput_buf_end); +} +#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && MINIZ_HAS_64BIT_REGISTERS */ + + static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block) + { + if (static_block) + tdefl_start_static_block(d); + else + tdefl_start_dynamic_block(d); + return tdefl_compress_lz_codes(d); + } + + static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 }; + + static int tdefl_flush_block(tdefl_compressor *d, int flush) + { + mz_uint saved_bit_buf, saved_bits_in; + mz_uint8 *pSaved_output_buf; + mz_bool comp_block_succeeded = MZ_FALSE; + 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; + 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; + + d->m_pOutput_buf = pOutput_buf_start; + d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; + + MZ_ASSERT(!d->m_output_flush_remaining); + d->m_output_flush_ofs = 0; + d->m_output_flush_remaining = 0; + + *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); + d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); + + if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) + { + const mz_uint8 cmf = 0x78; + mz_uint8 flg, flevel = 3; + mz_uint header, i, mz_un = sizeof(s_tdefl_num_probes) / sizeof(mz_uint); + + /* Determine compression level by reversing the process in tdefl_create_comp_flags_from_zip_params() */ + for (i = 0; i < mz_un; i++) + if (s_tdefl_num_probes[i] == (d->m_flags & 0xFFF)) + break; + + if (i < 2) + flevel = 0; + else if (i < 6) + flevel = 1; + else if (i == 6) + flevel = 2; + + header = cmf << 8 | (flevel << 6); + header += 31 - (header % 31); + flg = header & 0xFF; + + TDEFL_PUT_BITS(cmf, 8); + TDEFL_PUT_BITS(flg, 8); + } + + TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); + + pSaved_output_buf = d->m_pOutput_buf; + saved_bit_buf = d->m_bit_buffer; + saved_bits_in = d->m_bits_in; + + if (!use_raw_block) + comp_block_succeeded = tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || (d->m_total_lz_bytes < 48)); + + /* If the block gets expanded, forget the current contents of the output buffer and send a raw block instead. */ + if (((use_raw_block) || ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= d->m_total_lz_bytes))) && + ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) + { + mz_uint i; + d->m_pOutput_buf = pSaved_output_buf; + d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; + TDEFL_PUT_BITS(0, 2); + if (d->m_bits_in) + { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) + { + TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); + } + for (i = 0; i < d->m_total_lz_bytes; ++i) + { + TDEFL_PUT_BITS(d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], 8); + } + } + /* Check for the extremely unlikely (if not impossible) case of the compressed block not fitting into the output buffer when using dynamic codes. */ + else if (!comp_block_succeeded) + { + d->m_pOutput_buf = pSaved_output_buf; + d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; + tdefl_compress_block(d, MZ_TRUE); + } + + if (flush) + { + if (flush == TDEFL_FINISH) + { + if (d->m_bits_in) + { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) + { + mz_uint i, a = d->m_adler32; + for (i = 0; i < 4; i++) + { + TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); + a <<= 8; + } + } + } + else + { + mz_uint i, z = 0; + TDEFL_PUT_BITS(0, 3); + if (d->m_bits_in) + { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + for (i = 2; i; --i, z ^= 0xFFFF) + { + TDEFL_PUT_BITS(z & 0xFFFF, 16); + } + } + } + + MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); + + memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); + memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); + + d->m_pLZ_code_buf = d->m_lz_code_buf + 1; + d->m_pLZ_flags = d->m_lz_code_buf; + d->m_num_flags_left = 8; + d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; + d->m_total_lz_bytes = 0; + d->m_block_index++; + + if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) + { + if (d->m_pPut_buf_func) + { + *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; + if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) + return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); + } + else if (pOutput_buf_start == d->m_output_buf) + { + int bytes_to_copy = (int)MZ_MIN((size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); + memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, bytes_to_copy); + d->m_out_buf_ofs += bytes_to_copy; + if ((n -= bytes_to_copy) != 0) + { + d->m_output_flush_ofs = bytes_to_copy; + d->m_output_flush_remaining = n; + } + } + else + { + d->m_out_buf_ofs += n; + } + } + + return d->m_output_flush_remaining; + } + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8 *p) + { + mz_uint16 ret; + memcpy(&ret, p, sizeof(mz_uint16)); + return ret; + } + static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16 *p) + { + mz_uint16 ret; + memcpy(&ret, p, sizeof(mz_uint16)); + return ret; + } +#else +#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p) +#define TDEFL_READ_UNALIGNED_WORD2(p) *(const mz_uint16 *)(p) +#endif + 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) + { + mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len; + mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; + const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q; + mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), s01 = TDEFL_READ_UNALIGNED_WORD2(s); + MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); + if (max_match_len <= match_len) + return; + for (;;) + { + for (;;) + { + if (--num_probes_left == 0) + return; +#define TDEFL_PROBE \ + next_probe_pos = d->m_next[probe_pos]; \ + if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ + return; \ + probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ + if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) \ + break; + TDEFL_PROBE; + TDEFL_PROBE; + TDEFL_PROBE; + } + if (!dist) + break; + q = (const mz_uint16 *)(d->m_dict + probe_pos); + if (TDEFL_READ_UNALIGNED_WORD2(q) != s01) + continue; + p = s; + probe_len = 32; + do + { + } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0)); + if (!probe_len) + { + *pMatch_dist = dist; + *pMatch_len = MZ_MIN(max_match_len, (mz_uint)TDEFL_MAX_MATCH_LEN); + break; + } + else if ((probe_len = ((mz_uint)(p - s) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q)) > match_len) + { + *pMatch_dist = dist; + if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == max_match_len) + break; + c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]); + } + } + } +#else +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) +{ + mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, match_len = *pMatch_len, probe_pos = pos, next_probe_pos, probe_len; + mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; + const mz_uint8 *s = d->m_dict + pos, *p, *q; + mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; + MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); + if (max_match_len <= match_len) + return; + for (;;) + { + for (;;) + { + if (--num_probes_left == 0) + return; +#define TDEFL_PROBE \ + next_probe_pos = d->m_next[probe_pos]; \ + if ((!next_probe_pos) || ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ + return; \ + probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ + if ((d->m_dict[probe_pos + match_len] == c0) && (d->m_dict[probe_pos + match_len - 1] == c1)) \ + break; + TDEFL_PROBE; + TDEFL_PROBE; + TDEFL_PROBE; + } + if (!dist) + break; + p = s; + q = d->m_dict + probe_pos; + for (probe_len = 0; probe_len < max_match_len; probe_len++) + if (*p++ != *q++) + break; + if (probe_len > match_len) + { + *pMatch_dist = dist; + if ((*pMatch_len = match_len = probe_len) == max_match_len) + return; + c0 = d->m_dict[pos + match_len]; + c1 = d->m_dict[pos + match_len - 1]; + } + } +} +#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES */ + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8 *p) + { + mz_uint32 ret; + memcpy(&ret, p, sizeof(mz_uint32)); + return ret; + } +#else +#define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p) +#endif + static mz_bool tdefl_compress_fast(tdefl_compressor *d) + { + /* Faster, minimally featured LZRW1-style match+parse loop with better register utilization. Intended for applications where raw throughput is valued more highly than ratio. */ + 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; + mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags; + mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; + + while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size))) + { + const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096; + mz_uint dst_pos = (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; + mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size); + d->m_src_buf_left -= num_bytes_to_process; + lookahead_size += num_bytes_to_process; + + while (num_bytes_to_process) + { + mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process); + memcpy(d->m_dict + dst_pos, d->m_pSrc, n); + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos)); + d->m_pSrc += n; + dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK; + num_bytes_to_process -= n; + } + + dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size); + if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE)) + break; + + while (lookahead_size >= 4) + { + mz_uint cur_match_dist, cur_match_len = 1; + mz_uint8 *pCur_dict = d->m_dict + cur_pos; + mz_uint first_trigram = TDEFL_READ_UNALIGNED_WORD32(pCur_dict) & 0xFFFFFF; + mz_uint hash = (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & TDEFL_LEVEL1_HASH_SIZE_MASK; + mz_uint probe_pos = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)lookahead_pos; + + 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)) + { + const mz_uint16 *p = (const mz_uint16 *)pCur_dict; + const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos); + mz_uint32 probe_len = 32; + do + { + } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && (--probe_len > 0)); + cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q); + if (!probe_len) + cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0; + + if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || ((cur_match_len == TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 8U * 1024U))) + { + cur_match_len = 1; + *pLZ_code_buf++ = (mz_uint8)first_trigram; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + d->m_huff_count[0][(mz_uint8)first_trigram]++; + } + else + { + mz_uint32 s0, s1; + cur_match_len = MZ_MIN(cur_match_len, lookahead_size); + + MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && (cur_match_dist >= 1) && (cur_match_dist <= TDEFL_LZ_DICT_SIZE)); + + cur_match_dist--; + + pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN); +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist)); +#else + *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist; +#endif + pLZ_code_buf += 3; + *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80); + + s0 = s_tdefl_small_dist_sym[cur_match_dist & 511]; + s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8]; + d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++; + + d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - TDEFL_MIN_MATCH_LEN]]++; + } + } + else + { + *pLZ_code_buf++ = (mz_uint8)first_trigram; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + d->m_huff_count[0][(mz_uint8)first_trigram]++; + } + + if (--num_flags_left == 0) + { + num_flags_left = 8; + pLZ_flags = pLZ_code_buf++; + } + + total_lz_bytes += cur_match_len; + lookahead_pos += cur_match_len; + dict_size = MZ_MIN(dict_size + cur_match_len, (mz_uint)TDEFL_LZ_DICT_SIZE); + cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK; + MZ_ASSERT(lookahead_size >= cur_match_len); + lookahead_size -= cur_match_len; + + if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) + { + int n; + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + total_lz_bytes = d->m_total_lz_bytes; + pLZ_code_buf = d->m_pLZ_code_buf; + pLZ_flags = d->m_pLZ_flags; + num_flags_left = d->m_num_flags_left; + } + } + + while (lookahead_size) + { + mz_uint8 lit = d->m_dict[cur_pos]; + + total_lz_bytes++; + *pLZ_code_buf++ = lit; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + if (--num_flags_left == 0) + { + num_flags_left = 8; + pLZ_flags = pLZ_code_buf++; + } + + d->m_huff_count[0][lit]++; + + lookahead_pos++; + dict_size = MZ_MIN(dict_size + 1, (mz_uint)TDEFL_LZ_DICT_SIZE); + cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; + lookahead_size--; + + if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) + { + int n; + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + total_lz_bytes = d->m_total_lz_bytes; + pLZ_code_buf = d->m_pLZ_code_buf; + pLZ_flags = d->m_pLZ_flags; + num_flags_left = d->m_num_flags_left; + } + } + } + + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + return MZ_TRUE; + } +#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ + + static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, mz_uint8 lit) + { + d->m_total_lz_bytes++; + *d->m_pLZ_code_buf++ = lit; + *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); + if (--d->m_num_flags_left == 0) + { + d->m_num_flags_left = 8; + d->m_pLZ_flags = d->m_pLZ_code_buf++; + } + d->m_huff_count[0][lit]++; + } + + static MZ_FORCEINLINE void tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist) + { + mz_uint32 s0, s1; + + MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && (match_dist <= TDEFL_LZ_DICT_SIZE)); + + d->m_total_lz_bytes += match_len; + + d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); + + match_dist -= 1; + d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); + d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); + d->m_pLZ_code_buf += 3; + + *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); + if (--d->m_num_flags_left == 0) + { + d->m_num_flags_left = 8; + d->m_pLZ_flags = d->m_pLZ_code_buf++; + } + + s0 = s_tdefl_small_dist_sym[match_dist & 511]; + s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; + d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; + d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; + } + + static mz_bool tdefl_compress_normal(tdefl_compressor *d) + { + const mz_uint8 *pSrc = d->m_pSrc; + size_t src_buf_left = d->m_src_buf_left; + tdefl_flush flush = d->m_flush; + + while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) + { + mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos; + /* Update dictionary and hash chains. Keeps the lookahead size equal to TDEFL_MAX_MATCH_LEN. */ + if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) + { + 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; + 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]; + mz_uint num_bytes_to_process = (mz_uint)MZ_MIN(src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); + const mz_uint8 *pSrc_end = pSrc ? pSrc + num_bytes_to_process : NULL; + src_buf_left -= num_bytes_to_process; + d->m_lookahead_size += num_bytes_to_process; + while (pSrc != pSrc_end) + { + mz_uint8 c = *pSrc++; + d->m_dict[dst_pos] = c; + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; + hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); + d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)(ins_pos); + dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; + ins_pos++; + } + } + else + { + while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) + { + mz_uint8 c = *pSrc++; + mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; + src_buf_left--; + d->m_dict[dst_pos] = c; + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; + if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) + { + mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; + 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); + d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)(ins_pos); + } + } + } + d->m_dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); + if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) + break; + + /* Simple lazy/greedy parsing state machine. */ + len_to_move = 1; + cur_match_dist = 0; + cur_match_len = d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); + cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; + if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) + { + if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) + { + mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; + cur_match_len = 0; + while (cur_match_len < d->m_lookahead_size) + { + if (d->m_dict[cur_pos + cur_match_len] != c) + break; + cur_match_len++; + } + if (cur_match_len < TDEFL_MIN_MATCH_LEN) + cur_match_len = 0; + else + cur_match_dist = 1; + } + } + else + { + tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, d->m_lookahead_size, &cur_match_dist, &cur_match_len); + } + 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))) + { + cur_match_dist = cur_match_len = 0; + } + if (d->m_saved_match_len) + { + if (cur_match_len > d->m_saved_match_len) + { + tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); + if (cur_match_len >= 128) + { + tdefl_record_match(d, cur_match_len, cur_match_dist); + d->m_saved_match_len = 0; + len_to_move = cur_match_len; + } + else + { + d->m_saved_lit = d->m_dict[cur_pos]; + d->m_saved_match_dist = cur_match_dist; + d->m_saved_match_len = cur_match_len; + } + } + else + { + tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); + len_to_move = d->m_saved_match_len - 1; + d->m_saved_match_len = 0; + } + } + else if (!cur_match_dist) + tdefl_record_literal(d, d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); + else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || (cur_match_len >= 128)) + { + tdefl_record_match(d, cur_match_len, cur_match_dist); + len_to_move = cur_match_len; + } + else + { + d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; + d->m_saved_match_dist = cur_match_dist; + d->m_saved_match_len = cur_match_len; + } + /* Move the lookahead forward by len_to_move bytes. */ + d->m_lookahead_pos += len_to_move; + MZ_ASSERT(d->m_lookahead_size >= len_to_move); + d->m_lookahead_size -= len_to_move; + d->m_dict_size = MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); + /* Check if it's time to flush the current LZ codes to the internal output buffer. */ + if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || + ((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)))) + { + int n; + d->m_pSrc = pSrc; + d->m_src_buf_left = src_buf_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + } + } + + d->m_pSrc = pSrc; + d->m_src_buf_left = src_buf_left; + return MZ_TRUE; + } + + static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d) + { + if (d->m_pIn_buf_size) + { + *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; + } + + if (d->m_pOut_buf_size) + { + size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining); + memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n); + d->m_output_flush_ofs += (mz_uint)n; + d->m_output_flush_remaining -= (mz_uint)n; + d->m_out_buf_ofs += n; + + *d->m_pOut_buf_size = d->m_out_buf_ofs; + } + + return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY; + } + + 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) + { + if (!d) + { + if (pIn_buf_size) + *pIn_buf_size = 0; + if (pOut_buf_size) + *pOut_buf_size = 0; + return TDEFL_STATUS_BAD_PARAM; + } + + d->m_pIn_buf = pIn_buf; + d->m_pIn_buf_size = pIn_buf_size; + d->m_pOut_buf = pOut_buf; + d->m_pOut_buf_size = pOut_buf_size; + d->m_pSrc = (const mz_uint8 *)(pIn_buf); + d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; + d->m_out_buf_ofs = 0; + d->m_flush = flush; + + if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) || + (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf)) + { + if (pIn_buf_size) + *pIn_buf_size = 0; + if (pOut_buf_size) + *pOut_buf_size = 0; + return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); + } + d->m_wants_to_finish |= (flush == TDEFL_FINISH); + + if ((d->m_output_flush_remaining) || (d->m_finished)) + return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN + if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && + ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && + ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | TDEFL_RLE_MATCHES)) == 0)) + { + if (!tdefl_compress_fast(d)) + return d->m_prev_return_status; + } + else +#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ + { + if (!tdefl_compress_normal(d)) + return d->m_prev_return_status; + } + + if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf)) + d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf); + + if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining)) + { + if (tdefl_flush_block(d, flush) < 0) + return d->m_prev_return_status; + d->m_finished = (flush == TDEFL_FINISH); + if (flush == TDEFL_FULL_FLUSH) + { + MZ_CLEAR_ARR(d->m_hash); + MZ_CLEAR_ARR(d->m_next); + d->m_dict_size = 0; + } + } + + return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); + } + + tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush) + { + MZ_ASSERT(d->m_pPut_buf_func); + return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush); + } + + tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags) + { + d->m_pPut_buf_func = pPut_buf_func; + d->m_pPut_buf_user = pPut_buf_user; + d->m_flags = (mz_uint)(flags); + d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; + d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; + d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; + if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) + MZ_CLEAR_ARR(d->m_hash); + 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; + 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; + d->m_pLZ_code_buf = d->m_lz_code_buf + 1; + d->m_pLZ_flags = d->m_lz_code_buf; + *d->m_pLZ_flags = 0; + d->m_num_flags_left = 8; + d->m_pOutput_buf = d->m_output_buf; + d->m_pOutput_buf_end = d->m_output_buf; + d->m_prev_return_status = TDEFL_STATUS_OKAY; + d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; + d->m_adler32 = 1; + d->m_pIn_buf = NULL; + d->m_pOut_buf = NULL; + d->m_pIn_buf_size = NULL; + d->m_pOut_buf_size = NULL; + d->m_flush = TDEFL_NO_FLUSH; + d->m_pSrc = NULL; + d->m_src_buf_left = 0; + d->m_out_buf_ofs = 0; + if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) + MZ_CLEAR_ARR(d->m_dict); + memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); + memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); + return TDEFL_STATUS_OKAY; + } + + tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d) + { + return d->m_prev_return_status; + } + + mz_uint32 tdefl_get_adler32(tdefl_compressor *d) + { + return d->m_adler32; + } + + 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) + { + tdefl_compressor *pComp; + mz_bool succeeded; + if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) + return MZ_FALSE; + pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); + if (!pComp) + return MZ_FALSE; + succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY); + succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE); + MZ_FREE(pComp); + return succeeded; + } + + typedef struct + { + size_t m_size, m_capacity; + mz_uint8 *m_pBuf; + mz_bool m_expandable; + } tdefl_output_buffer; + + static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser) + { + tdefl_output_buffer *p = (tdefl_output_buffer *)pUser; + size_t new_size = p->m_size + len; + if (new_size > p->m_capacity) + { + size_t new_capacity = p->m_capacity; + mz_uint8 *pNew_buf; + if (!p->m_expandable) + return MZ_FALSE; + do + { + new_capacity = MZ_MAX(128U, new_capacity << 1U); + } while (new_size > new_capacity); + pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity); + if (!pNew_buf) + return MZ_FALSE; + p->m_pBuf = pNew_buf; + p->m_capacity = new_capacity; + } + memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len); + p->m_size = new_size; + return MZ_TRUE; + } + + void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags) + { + tdefl_output_buffer out_buf; + MZ_CLEAR_OBJ(out_buf); + if (!pOut_len) + return MZ_FALSE; + else + *pOut_len = 0; + out_buf.m_expandable = MZ_TRUE; + if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) + return NULL; + *pOut_len = out_buf.m_size; + return out_buf.m_pBuf; + } + + 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) + { + tdefl_output_buffer out_buf; + MZ_CLEAR_OBJ(out_buf); + if (!pOut_buf) + return 0; + out_buf.m_pBuf = (mz_uint8 *)pOut_buf; + out_buf.m_capacity = out_buf_len; + if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) + return 0; + return out_buf.m_size; + } + + /* 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). */ + mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy) + { + mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); + if (window_bits > 0) + comp_flags |= TDEFL_WRITE_ZLIB_HEADER; + + if (!level) + comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; + else if (strategy == MZ_FILTERED) + comp_flags |= TDEFL_FILTER_MATCHES; + else if (strategy == MZ_HUFFMAN_ONLY) + comp_flags &= ~TDEFL_MAX_PROBES_MASK; + else if (strategy == MZ_FIXED) + comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; + else if (strategy == MZ_RLE) + comp_flags |= TDEFL_RLE_MATCHES; + + return comp_flags; + } + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4204) /* nonstandard extension used : non-constant aggregate initializer (also supported by GNU C and C99, so no big deal) */ +#endif + + /* Simple PNG writer function by Alex Evans, 2011. Released into the public domain: https://gist.github.com/908299, more context at + http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/. + This is actually a modification of Alex's original code so PNG files generated by this function pass pngcheck. */ + 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) + { + /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */ + static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 }; + tdefl_compressor *pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); + tdefl_output_buffer out_buf; + int i, bpl = w * num_chans, y, z; + mz_uint32 c; + *pLen_out = 0; + if (!pComp) + return NULL; + MZ_CLEAR_OBJ(out_buf); + out_buf.m_expandable = MZ_TRUE; + out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h); + if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity))) + { + MZ_FREE(pComp); + return NULL; + } + /* write dummy header */ + for (z = 41; z; --z) + tdefl_output_buffer_putter(&z, 1, &out_buf); + /* compress image data */ + tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER); + for (y = 0; y < h; ++y) + { + tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH); + tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH); + } + if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != TDEFL_STATUS_DONE) + { + MZ_FREE(pComp); + MZ_FREE(out_buf.m_pBuf); + return NULL; + } + /* write real header */ + *pLen_out = out_buf.m_size - 41; + { + static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 }; + mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, + 0x0a, 0x1a, 0x0a, 0x00, 0x00, + 0x00, 0x0d, 0x49, 0x48, 0x44, + 0x52, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x08, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x49, 0x44, 0x41, + 0x54 }; + pnghdr[18] = (mz_uint8)(w >> 8); + pnghdr[19] = (mz_uint8)w; + pnghdr[22] = (mz_uint8)(h >> 8); + pnghdr[23] = (mz_uint8)h; + pnghdr[25] = chans[num_chans]; + pnghdr[33] = (mz_uint8)(*pLen_out >> 24); + pnghdr[34] = (mz_uint8)(*pLen_out >> 16); + pnghdr[35] = (mz_uint8)(*pLen_out >> 8); + pnghdr[36] = (mz_uint8)*pLen_out; + c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17); + for (i = 0; i < 4; ++i, c <<= 8) + ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24); + memcpy(out_buf.m_pBuf, pnghdr, 41); + } + /* write footer (IDAT CRC-32, followed by IEND chunk) */ + if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf)) + { + *pLen_out = 0; + MZ_FREE(pComp); + MZ_FREE(out_buf.m_pBuf); + return NULL; + } + c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4); + for (i = 0; i < 4; ++i, c <<= 8) + (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24); + /* compute final size of file, grab compressed data buffer and return */ + *pLen_out += 57; + MZ_FREE(pComp); + return out_buf.m_pBuf; + } + void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out) + { + /* 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) */ + return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE); + } + +#ifndef MINIZ_NO_MALLOC + /* Allocate the tdefl_compressor and tinfl_decompressor structures in C so that */ + /* non-C language bindings to tdefL_ and tinfl_ API don't need to worry about */ + /* structure size and allocation mechanism. */ + tdefl_compressor *tdefl_compressor_alloc(void) + { + return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); + } + + void tdefl_compressor_free(tdefl_compressor *pComp) + { + MZ_FREE(pComp); + } +#endif + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/ + /************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + + +#ifndef MINIZ_NO_INFLATE_APIS + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* ------------------- Low-level Decompression (completely independent from all compression API's) */ + +#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) +#define TINFL_MEMSET(p, c, l) memset(p, c, l) + +#define TINFL_CR_BEGIN \ + switch (r->m_state) \ + { \ + case 0: +#define TINFL_CR_RETURN(state_index, result) \ + do \ + { \ + status = result; \ + r->m_state = state_index; \ + goto common_exit; \ + case state_index:; \ + } \ + MZ_MACRO_END +#define TINFL_CR_RETURN_FOREVER(state_index, result) \ + do \ + { \ + for (;;) \ + { \ + TINFL_CR_RETURN(state_index, result); \ + } \ + } \ + MZ_MACRO_END +#define TINFL_CR_FINISH } + +#define TINFL_GET_BYTE(state_index, c) \ + do \ + { \ + while (pIn_buf_cur >= pIn_buf_end) \ + { \ + TINFL_CR_RETURN(state_index, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ + } \ + c = *pIn_buf_cur++; \ + } \ + MZ_MACRO_END + +#define TINFL_NEED_BITS(state_index, n) \ + do \ + { \ + mz_uint c; \ + TINFL_GET_BYTE(state_index, c); \ + bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ + num_bits += 8; \ + } while (num_bits < (mz_uint)(n)) +#define TINFL_SKIP_BITS(state_index, n) \ + do \ + { \ + if (num_bits < (mz_uint)(n)) \ + { \ + TINFL_NEED_BITS(state_index, n); \ + } \ + bit_buf >>= (n); \ + num_bits -= (n); \ + } \ + MZ_MACRO_END +#define TINFL_GET_BITS(state_index, b, n) \ + do \ + { \ + if (num_bits < (mz_uint)(n)) \ + { \ + TINFL_NEED_BITS(state_index, n); \ + } \ + b = bit_buf & ((1 << (n)) - 1); \ + bit_buf >>= (n); \ + num_bits -= (n); \ + } \ + MZ_MACRO_END + +/* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes remaining in the input buffer falls below 2. */ +/* 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 */ +/* 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 */ +/* bit buffer contains >=15 bits (deflate's max. Huffman code size). */ +#define TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree) \ + do \ + { \ + temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ + if (temp >= 0) \ + { \ + code_len = temp >> 9; \ + if ((code_len) && (num_bits >= code_len)) \ + break; \ + } \ + else if (num_bits > TINFL_FAST_LOOKUP_BITS) \ + { \ + code_len = TINFL_FAST_LOOKUP_BITS; \ + do \ + { \ + temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ + } while ((temp < 0) && (num_bits >= (code_len + 1))); \ + if (temp >= 0) \ + break; \ + } \ + TINFL_GET_BYTE(state_index, c); \ + bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ + num_bits += 8; \ + } while (num_bits < 15); + +/* 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 */ +/* 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 */ +/* 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. */ +/* The slow path is only executed at the very end of the input buffer. */ +/* 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 */ +/* following the deflate data and our non-conservative read-ahead path won't kick in here on this code. This is much trickier. */ +#define TINFL_HUFF_DECODE(state_index, sym, pLookUp, pTree) \ + do \ + { \ + int temp; \ + mz_uint code_len, c; \ + if (num_bits < 15) \ + { \ + if ((pIn_buf_end - pIn_buf_cur) < 2) \ + { \ + TINFL_HUFF_BITBUF_FILL(state_index, pLookUp, pTree); \ + } \ + else \ + { \ + bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ + pIn_buf_cur += 2; \ + num_bits += 16; \ + } \ + } \ + if ((temp = pLookUp[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) \ + code_len = temp >> 9, temp &= 511; \ + else \ + { \ + code_len = TINFL_FAST_LOOKUP_BITS; \ + do \ + { \ + temp = pTree[~temp + ((bit_buf >> code_len++) & 1)]; \ + } while (temp < 0); \ + } \ + sym = temp; \ + bit_buf >>= code_len; \ + num_bits -= code_len; \ + } \ + MZ_MACRO_END + + static void tinfl_clear_tree(tinfl_decompressor *r) + { + if (r->m_type == 0) + MZ_CLEAR_ARR(r->m_tree_0); + else if (r->m_type == 1) + MZ_CLEAR_ARR(r->m_tree_1); + else + MZ_CLEAR_ARR(r->m_tree_2); + } + + 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) + { + 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 }; + 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 }; + 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 }; + 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 }; + 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 }; + static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 }; + + mz_int16 *pTrees[3]; + mz_uint8 *pCode_sizes[3]; + + tinfl_status status = TINFL_STATUS_FAILED; + mz_uint32 num_bits, dist, counter, num_extra; + tinfl_bit_buf_t bit_buf; + const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size; + mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL; + 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; + + /* 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). */ + if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start)) + { + *pIn_buf_size = *pOut_buf_size = 0; + return TINFL_STATUS_BAD_PARAM; + } + + pTrees[0] = r->m_tree_0; + pTrees[1] = r->m_tree_1; + pTrees[2] = r->m_tree_2; + pCode_sizes[0] = r->m_code_size_0; + pCode_sizes[1] = r->m_code_size_1; + pCode_sizes[2] = r->m_code_size_2; + + num_bits = r->m_num_bits; + bit_buf = r->m_bit_buf; + dist = r->m_dist; + counter = r->m_counter; + num_extra = r->m_num_extra; + dist_from_out_buf_start = r->m_dist_from_out_buf_start; + TINFL_CR_BEGIN + + bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; + r->m_z_adler32 = r->m_check_adler32 = 1; + if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) + { + TINFL_GET_BYTE(1, r->m_zhdr0); + TINFL_GET_BYTE(2, r->m_zhdr1); + counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); + if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) + counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4))))); + if (counter) + { + TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); + } + } + + do + { + TINFL_GET_BITS(3, r->m_final, 3); + r->m_type = r->m_final >> 1; + if (r->m_type == 0) + { + TINFL_SKIP_BITS(5, num_bits & 7); + for (counter = 0; counter < 4; ++counter) + { + if (num_bits) + TINFL_GET_BITS(6, r->m_raw_header[counter], 8); + else + TINFL_GET_BYTE(7, r->m_raw_header[counter]); + } + 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)))) + { + TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); + } + while ((counter) && (num_bits)) + { + TINFL_GET_BITS(51, dist, 8); + while (pOut_buf_cur >= pOut_buf_end) + { + TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = (mz_uint8)dist; + counter--; + } + while (counter) + { + size_t n; + while (pOut_buf_cur >= pOut_buf_end) + { + TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); + } + while (pIn_buf_cur >= pIn_buf_end) + { + TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) ? TINFL_STATUS_NEEDS_MORE_INPUT : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); + } + n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter); + TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); + pIn_buf_cur += n; + pOut_buf_cur += n; + counter -= (mz_uint)n; + } + } + else if (r->m_type == 3) + { + TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); + } + else + { + if (r->m_type == 1) + { + mz_uint8 *p = r->m_code_size_0; + mz_uint i; + r->m_table_sizes[0] = 288; + r->m_table_sizes[1] = 32; + TINFL_MEMSET(r->m_code_size_1, 5, 32); + for (i = 0; i <= 143; ++i) + *p++ = 8; + for (; i <= 255; ++i) + *p++ = 9; + for (; i <= 279; ++i) + *p++ = 7; + for (; i <= 287; ++i) + *p++ = 8; + } + else + { + for (counter = 0; counter < 3; counter++) + { + TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); + r->m_table_sizes[counter] += s_min_table_sizes[counter]; + } + MZ_CLEAR_ARR(r->m_code_size_2); + for (counter = 0; counter < r->m_table_sizes[2]; counter++) + { + mz_uint s; + TINFL_GET_BITS(14, s, 3); + r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s; + } + r->m_table_sizes[2] = 19; + } + for (; (int)r->m_type >= 0; r->m_type--) + { + int tree_next, tree_cur; + mz_int16 *pLookUp; + mz_int16 *pTree; + mz_uint8 *pCode_size; + mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16]; + pLookUp = r->m_look_up[r->m_type]; + pTree = pTrees[r->m_type]; + pCode_size = pCode_sizes[r->m_type]; + MZ_CLEAR_ARR(total_syms); + TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0])); + tinfl_clear_tree(r); + for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) + total_syms[pCode_size[i]]++; + used_syms = 0, total = 0; + next_code[0] = next_code[1] = 0; + for (i = 1; i <= 15; ++i) + { + used_syms += total_syms[i]; + next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); + } + if ((65536 != total) && (used_syms > 1)) + { + TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); + } + for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index) + { + mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index]; + if (!code_size) + continue; + cur_code = next_code[code_size]++; + for (l = code_size; l > 0; l--, cur_code >>= 1) + rev_code = (rev_code << 1) | (cur_code & 1); + if (code_size <= TINFL_FAST_LOOKUP_BITS) + { + mz_int16 k = (mz_int16)((code_size << 9) | sym_index); + while (rev_code < TINFL_FAST_LOOKUP_SIZE) + { + pLookUp[rev_code] = k; + rev_code += (1 << code_size); + } + continue; + } + if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)])) + { + pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next; + tree_cur = tree_next; + tree_next -= 2; + } + rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); + for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) + { + tree_cur -= ((rev_code >>= 1) & 1); + if (!pTree[-tree_cur - 1]) + { + pTree[-tree_cur - 1] = (mz_int16)tree_next; + tree_cur = tree_next; + tree_next -= 2; + } + else + tree_cur = pTree[-tree_cur - 1]; + } + tree_cur -= ((rev_code >>= 1) & 1); + pTree[-tree_cur - 1] = (mz_int16)sym_index; + } + if (r->m_type == 2) + { + for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) + { + mz_uint s; + TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2); + if (dist < 16) + { + r->m_len_codes[counter++] = (mz_uint8)dist; + continue; + } + if ((dist == 16) && (!counter)) + { + TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); + } + num_extra = "\02\03\07"[dist - 16]; + TINFL_GET_BITS(18, s, num_extra); + s += "\03\03\013"[dist - 16]; + TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); + counter += s; + } + if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) + { + TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); + } + TINFL_MEMCPY(r->m_code_size_0, r->m_len_codes, r->m_table_sizes[0]); + TINFL_MEMCPY(r->m_code_size_1, r->m_len_codes + r->m_table_sizes[0], r->m_table_sizes[1]); + } + } + for (;;) + { + mz_uint8 *pSrc; + for (;;) + { + if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2)) + { + TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0); + if (counter >= 256) + break; + while (pOut_buf_cur >= pOut_buf_end) + { + TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = (mz_uint8)counter; + } + else + { + int sym2; + mz_uint code_len; +#if TINFL_USE_64BIT_BITBUF + if (num_bits < 30) + { + bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 4; + num_bits += 32; + } +#else + if (num_bits < 15) + { + bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 2; + num_bits += 16; + } +#endif + if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) + code_len = sym2 >> 9; + else + { + code_len = TINFL_FAST_LOOKUP_BITS; + do + { + sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; + } while (sym2 < 0); + } + counter = sym2; + bit_buf >>= code_len; + num_bits -= code_len; + if (counter & 256) + break; + +#if !TINFL_USE_64BIT_BITBUF + if (num_bits < 15) + { + bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 2; + num_bits += 16; + } +#endif + if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0) + code_len = sym2 >> 9; + else + { + code_len = TINFL_FAST_LOOKUP_BITS; + do + { + sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)]; + } while (sym2 < 0); + } + bit_buf >>= code_len; + num_bits -= code_len; + + /* assert(sym2 != 0 && counter != 0); */ + if (sym2 == 0 && counter == 0) + { + TINFL_CR_RETURN_FOREVER(40, TINFL_STATUS_FAILED); + } + + pOut_buf_cur[0] = (mz_uint8)counter; + if (sym2 & 256) + { + pOut_buf_cur++; + counter = sym2; + break; + } + pOut_buf_cur[1] = (mz_uint8)sym2; + pOut_buf_cur += 2; + } + } + if ((counter &= 511) == 256) + break; + + num_extra = s_length_extra[counter - 257]; + counter = s_length_base[counter - 257]; + if (num_extra) + { + mz_uint extra_bits; + TINFL_GET_BITS(25, extra_bits, num_extra); + counter += extra_bits; + } + + TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1); + num_extra = s_dist_extra[dist]; + dist = s_dist_base[dist]; + if (num_extra) + { + mz_uint extra_bits; + TINFL_GET_BITS(27, extra_bits, num_extra); + dist += extra_bits; + } + + dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; + if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) + { + TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); + } + + pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask); + + if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) + { + while (counter--) + { + while (pOut_buf_cur >= pOut_buf_end) + { + TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask]; + } + continue; + } +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES + else if ((counter >= 9) && (counter <= dist)) + { + const mz_uint8 *pSrc_end = pSrc + (counter & ~7); + do + { +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32) * 2); +#else + ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; + ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; +#endif + pOut_buf_cur += 8; + } while ((pSrc += 8) < pSrc_end); + if ((counter &= 7) < 3) + { + if (counter) + { + pOut_buf_cur[0] = pSrc[0]; + if (counter > 1) + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur += counter; + } + continue; + } + } +#endif + while (counter > 2) + { + pOut_buf_cur[0] = pSrc[0]; + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur[2] = pSrc[2]; + pOut_buf_cur += 3; + pSrc += 3; + counter -= 3; + } + if (counter > 0) + { + pOut_buf_cur[0] = pSrc[0]; + if (counter > 1) + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur += counter; + } + } + } + } while (!(r->m_final & 1)); + + /* 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. */ + /* 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. */ + TINFL_SKIP_BITS(32, num_bits & 7); + while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) + { + --pIn_buf_cur; + num_bits -= 8; + } + bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits); + 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). */ + + if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) + { + for (counter = 0; counter < 4; ++counter) + { + mz_uint s; + if (num_bits) + TINFL_GET_BITS(41, s, 8); + else + TINFL_GET_BYTE(42, s); + r->m_z_adler32 = (r->m_z_adler32 << 8) | s; + } + } + TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); + + TINFL_CR_FINISH + + common_exit: + /* As long as we aren't telling the caller that we NEED more input to make forward progress: */ + /* 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. */ + /* 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. */ + if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) + { + while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) + { + --pIn_buf_cur; + num_bits -= 8; + } + } + r->m_num_bits = num_bits; + r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits); + r->m_dist = dist; + r->m_counter = counter; + r->m_num_extra = num_extra; + r->m_dist_from_out_buf_start = dist_from_out_buf_start; + *pIn_buf_size = pIn_buf_cur - pIn_buf_next; + *pOut_buf_size = pOut_buf_cur - pOut_buf_next; + if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0)) + { + const mz_uint8 *ptr = pOut_buf_next; + size_t buf_len = *pOut_buf_size; + mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16; + size_t block_len = buf_len % 5552; + while (buf_len) + { + for (i = 0; i + 7 < block_len; i += 8, ptr += 8) + { + s1 += ptr[0], s2 += s1; + s1 += ptr[1], s2 += s1; + s1 += ptr[2], s2 += s1; + s1 += ptr[3], s2 += s1; + s1 += ptr[4], s2 += s1; + s1 += ptr[5], s2 += s1; + s1 += ptr[6], s2 += s1; + s1 += ptr[7], s2 += s1; + } + for (; i < block_len; ++i) + s1 += *ptr++, s2 += s1; + s1 %= 65521U, s2 %= 65521U; + buf_len -= block_len; + block_len = 5552; + } + r->m_check_adler32 = (s2 << 16) + s1; + if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32)) + status = TINFL_STATUS_ADLER32_MISMATCH; + } + return status; + } + + /* Higher level helper functions. */ + void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags) + { + tinfl_decompressor decomp; + void *pBuf = NULL, *pNew_buf; + size_t src_buf_ofs = 0, out_buf_capacity = 0; + *pOut_len = 0; + tinfl_init(&decomp); + for (;;) + { + size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity; + 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, + (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF); + if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT)) + { + MZ_FREE(pBuf); + *pOut_len = 0; + return NULL; + } + src_buf_ofs += src_buf_size; + *pOut_len += dst_buf_size; + if (status == TINFL_STATUS_DONE) + break; + new_out_buf_capacity = out_buf_capacity * 2; + if (new_out_buf_capacity < 128) + new_out_buf_capacity = 128; + pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity); + if (!pNew_buf) + { + MZ_FREE(pBuf); + *pOut_len = 0; + return NULL; + } + pBuf = pNew_buf; + out_buf_capacity = new_out_buf_capacity; + } + return pBuf; + } + + 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) + { + tinfl_decompressor decomp; + tinfl_status status; + tinfl_init(&decomp); + 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); + return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len; + } + + 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) + { + int result = 0; + tinfl_decompressor decomp; + mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE); + size_t in_buf_ofs = 0, dict_ofs = 0; + if (!pDict) + return TINFL_STATUS_FAILED; + memset(pDict, 0, TINFL_LZ_DICT_SIZE); + tinfl_init(&decomp); + for (;;) + { + size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs; + tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size, + (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))); + in_buf_ofs += in_buf_size; + if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user))) + break; + if (status != TINFL_STATUS_HAS_MORE_OUTPUT) + { + result = (status == TINFL_STATUS_DONE); + break; + } + dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1); + } + MZ_FREE(pDict); + *pIn_buf_size = in_buf_ofs; + return result; + } + +#ifndef MINIZ_NO_MALLOC + tinfl_decompressor *tinfl_decompressor_alloc(void) + { + tinfl_decompressor *pDecomp = (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor)); + if (pDecomp) + tinfl_init(pDecomp); + return pDecomp; + } + + void tinfl_decompressor_free(tinfl_decompressor *pDecomp) + { + MZ_FREE(pDecomp); + } +#endif + +#ifdef __cplusplus +} +#endif + +#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/ + /************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * Copyright 2016 Martin Raiber + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + +#ifndef MINIZ_NO_ARCHIVE_APIS + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* ------------------- .ZIP archive reading */ + +#ifdef MINIZ_NO_STDIO +#define MZ_FILE void * +#else +#include + +#if defined(_MSC_VER) || defined(__MINGW64__) || defined(__MINGW32__) + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#ifndef __cplusplus +#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0 +#endif +#ifndef NOMINMAX +#define NOMINMAX +#endif +#include + +static WCHAR *mz_utf8z_to_widechar(const char *str) +{ + int reqChars = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); + WCHAR *wStr = (WCHAR *)malloc(reqChars * sizeof(WCHAR)); + MultiByteToWideChar(CP_UTF8, 0, str, -1, wStr, reqChars); + return wStr; +} + +static FILE *mz_fopen(const char *pFilename, const char *pMode) +{ + WCHAR *wFilename = mz_utf8z_to_widechar(pFilename); + WCHAR *wMode = mz_utf8z_to_widechar(pMode); + FILE *pFile = NULL; + errno_t err = _wfopen_s(&pFile, wFilename, wMode); + free(wFilename); + free(wMode); + return err ? NULL : pFile; +} + +static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) +{ + WCHAR *wPath = mz_utf8z_to_widechar(pPath); + WCHAR *wMode = mz_utf8z_to_widechar(pMode); + FILE *pFile = NULL; + errno_t err = _wfreopen_s(&pFile, wPath, wMode, pStream); + free(wPath); + free(wMode); + return err ? NULL : pFile; +} + +#if defined(__MINGW32__) +static int mz_stat(const char *path, struct _stat *buffer) +{ + WCHAR *wPath = mz_utf8z_to_widechar(path); + int res = _wstat(wPath, buffer); + free(wPath); + return res; +} +#else +static int mz_stat64(const char *path, struct __stat64 *buffer) +{ + WCHAR *wPath = mz_utf8z_to_widechar(path); + int res = _wstat64(wPath, buffer); + free(wPath); + return res; +} +#endif + +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN mz_fopen +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 _ftelli64 +#define MZ_FSEEK64 _fseeki64 +#if defined(__MINGW32__) +#define MZ_FILE_STAT_STRUCT _stat +#define MZ_FILE_STAT mz_stat +#else +#define MZ_FILE_STAT_STRUCT _stat64 +#define MZ_FILE_STAT mz_stat64 +#endif +#define MZ_FFLUSH fflush +#define MZ_FREOPEN mz_freopen +#define MZ_DELETE_FILE remove + +#elif defined(__WATCOMC__) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 _ftelli64 +#define MZ_FSEEK64 _fseeki64 +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove + +#elif defined(__TINYC__) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftell +#define MZ_FSEEK64 fseek +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove + +#elif defined(__USE_LARGEFILE64) /* gcc, clang */ +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen64(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftello64 +#define MZ_FSEEK64 fseeko64 +#define MZ_FILE_STAT_STRUCT stat64 +#define MZ_FILE_STAT stat64 +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(p, m, s) freopen64(p, m, s) +#define MZ_DELETE_FILE remove + +#elif defined(__APPLE__) || defined(__FreeBSD__) || (defined(__linux__) && defined(__x86_64__)) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftello +#define MZ_FSEEK64 fseeko +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(p, m, s) freopen(p, m, s) +#define MZ_DELETE_FILE remove + +#else +#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.") +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#ifdef __STRICT_ANSI__ +#define MZ_FTELL64 ftell +#define MZ_FSEEK64 fseek +#else +#define MZ_FTELL64 ftello +#define MZ_FSEEK64 fseeko +#endif +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove +#endif /* #ifdef _MSC_VER */ +#endif /* #ifdef MINIZ_NO_STDIO */ + +#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c)) + + /* 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. */ + enum + { + /* ZIP archive identifiers and record sizes */ + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50, + MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50, + MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22, + + /* ZIP64 archive identifier and record sizes */ + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20, + MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001, + MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50, + MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24, + MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16, + + /* Central directory header record offsets */ + MZ_ZIP_CDH_SIG_OFS = 0, + MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4, + MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6, + MZ_ZIP_CDH_BIT_FLAG_OFS = 8, + MZ_ZIP_CDH_METHOD_OFS = 10, + MZ_ZIP_CDH_FILE_TIME_OFS = 12, + MZ_ZIP_CDH_FILE_DATE_OFS = 14, + MZ_ZIP_CDH_CRC32_OFS = 16, + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20, + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24, + MZ_ZIP_CDH_FILENAME_LEN_OFS = 28, + MZ_ZIP_CDH_EXTRA_LEN_OFS = 30, + MZ_ZIP_CDH_COMMENT_LEN_OFS = 32, + MZ_ZIP_CDH_DISK_START_OFS = 34, + MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36, + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38, + MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42, + + /* Local directory header offsets */ + MZ_ZIP_LDH_SIG_OFS = 0, + MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4, + MZ_ZIP_LDH_BIT_FLAG_OFS = 6, + MZ_ZIP_LDH_METHOD_OFS = 8, + MZ_ZIP_LDH_FILE_TIME_OFS = 10, + MZ_ZIP_LDH_FILE_DATE_OFS = 12, + MZ_ZIP_LDH_CRC32_OFS = 14, + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18, + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22, + MZ_ZIP_LDH_FILENAME_LEN_OFS = 26, + MZ_ZIP_LDH_EXTRA_LEN_OFS = 28, + MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3, + + /* End of central directory offsets */ + MZ_ZIP_ECDH_SIG_OFS = 0, + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4, + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6, + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8, + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10, + MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12, + MZ_ZIP_ECDH_CDIR_OFS_OFS = 16, + MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20, + + /* ZIP64 End of central directory locator offsets */ + MZ_ZIP64_ECDL_SIG_OFS = 0, /* 4 bytes */ + MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4, /* 4 bytes */ + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8, /* 8 bytes */ + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */ + + /* ZIP64 End of central directory header offsets */ + MZ_ZIP64_ECDH_SIG_OFS = 0, /* 4 bytes */ + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4, /* 8 bytes */ + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12, /* 2 bytes */ + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14, /* 2 bytes */ + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16, /* 4 bytes */ + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20, /* 4 bytes */ + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48, /* 8 bytes */ + MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0, + MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11 + }; + + typedef struct + { + void *m_p; + size_t m_size, m_capacity; + mz_uint m_element_size; + } mz_zip_array; + + struct mz_zip_internal_state_tag + { + mz_zip_array m_central_dir; + mz_zip_array m_central_dir_offsets; + mz_zip_array m_sorted_central_dir_offsets; + + /* The flags passed in when the archive is initially opened. */ + mz_uint32 m_init_flags; + + /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. */ + mz_bool m_zip64; + + /* 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.) */ + mz_bool m_zip64_has_extended_info_fields; + + /* These fields are used by the file, FILE, memory, and memory/heap read/write helpers. */ + MZ_FILE *m_pFile; + mz_uint64 m_file_archive_start_ofs; + + void *m_pMem; + size_t m_mem_size; + size_t m_mem_capacity; + }; + +#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size + +#if defined(DEBUG) || defined(_DEBUG) + static MZ_FORCEINLINE mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index) + { + MZ_ASSERT(index < pArray->m_size); + return index; + } +#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)] +#else +#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index] +#endif + + static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size) + { + memset(pArray, 0, sizeof(mz_zip_array)); + pArray->m_element_size = element_size; + } + + static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p); + memset(pArray, 0, sizeof(mz_zip_array)); + } + + static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing) + { + void *pNew_p; + size_t new_capacity = min_new_capacity; + MZ_ASSERT(pArray->m_element_size); + if (pArray->m_capacity >= min_new_capacity) + return MZ_TRUE; + if (growing) + { + new_capacity = MZ_MAX(1, pArray->m_capacity); + while (new_capacity < min_new_capacity) + new_capacity *= 2; + } + if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity))) + return MZ_FALSE; + pArray->m_p = pNew_p; + pArray->m_capacity = new_capacity; + return MZ_TRUE; + } + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing) + { + if (new_capacity > pArray->m_capacity) + { + if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) + return MZ_FALSE; + } + return MZ_TRUE; + } +#endif + + static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing) + { + if (new_size > pArray->m_capacity) + { + if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) + return MZ_FALSE; + } + pArray->m_size = new_size; + return MZ_TRUE; + } + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n) + { + return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE); + } + + static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n) + { + size_t orig_size = pArray->m_size; + if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) + return MZ_FALSE; + if (n > 0) + memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size); + return MZ_TRUE; + } +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */ + +#ifndef MINIZ_NO_TIME + static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date) + { + struct tm tm; + memset(&tm, 0, sizeof(tm)); + tm.tm_isdst = -1; + tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900; + tm.tm_mon = ((dos_date >> 5) & 15) - 1; + tm.tm_mday = dos_date & 31; + tm.tm_hour = (dos_time >> 11) & 31; + tm.tm_min = (dos_time >> 5) & 63; + tm.tm_sec = (dos_time << 1) & 62; + return mktime(&tm); + } + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date) + { +#ifdef _MSC_VER + struct tm tm_struct; + struct tm *tm = &tm_struct; + errno_t err = localtime_s(tm, &time); + if (err) + { + *pDOS_date = 0; + *pDOS_time = 0; + return; + } +#else + struct tm *tm = localtime(&time); +#endif /* #ifdef _MSC_VER */ + + *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1)); + *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday); + } +#endif /* MINIZ_NO_ARCHIVE_WRITING_APIS */ + +#ifndef MINIZ_NO_STDIO +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime) + { + struct MZ_FILE_STAT_STRUCT file_stat; + + /* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */ + if (MZ_FILE_STAT(pFilename, &file_stat) != 0) + return MZ_FALSE; + + *pTime = file_stat.st_mtime; + + return MZ_TRUE; + } +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS*/ + + static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time) + { + struct utimbuf t; + + memset(&t, 0, sizeof(t)); + t.actime = access_time; + t.modtime = modified_time; + + return !utime(pFilename, &t); + } +#endif /* #ifndef MINIZ_NO_STDIO */ +#endif /* #ifndef MINIZ_NO_TIME */ + + static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num) + { + if (pZip) + pZip->m_last_error = err_num; + return MZ_FALSE; + } + + static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags) + { + (void)flags; + if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!pZip->m_pAlloc) + pZip->m_pAlloc = miniz_def_alloc_func; + if (!pZip->m_pFree) + pZip->m_pFree = miniz_def_free_func; + if (!pZip->m_pRealloc) + pZip->m_pRealloc = miniz_def_realloc_func; + + pZip->m_archive_size = 0; + pZip->m_central_directory_file_ofs = 0; + pZip->m_total_files = 0; + pZip->m_last_error = MZ_ZIP_NO_ERROR; + + if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32)); + pZip->m_pState->m_init_flags = flags; + pZip->m_pState->m_zip64 = MZ_FALSE; + pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE; + + pZip->m_zip_mode = MZ_ZIP_MODE_READING; + + return MZ_TRUE; + } + + 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) + { + 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; + const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index)); + 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); + mz_uint8 l = 0, r = 0; + pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pE = pL + MZ_MIN(l_len, r_len); + while (pL < pE) + { + if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) + break; + pL++; + pR++; + } + return (pL == pE) ? (l_len < r_len) : (l < r); + } + +#define MZ_SWAP_UINT32(a, b) \ + do \ + { \ + mz_uint32 t = a; \ + a = b; \ + b = t; \ + } \ + MZ_MACRO_END + + /* 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.) */ + static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) + { + mz_zip_internal_state *pState = pZip->m_pState; + const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; + const mz_zip_array *pCentral_dir = &pState->m_central_dir; + mz_uint32 *pIndices; + mz_uint32 start, end; + const mz_uint32 size = pZip->m_total_files; + + if (size <= 1U) + return; + + pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0); + + start = (size - 2U) >> 1U; + for (;;) + { + mz_uint64 child, root = start; + for (;;) + { + if ((child = (root << 1U) + 1U) >= size) + break; + child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]))); + if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child])) + break; + MZ_SWAP_UINT32(pIndices[root], pIndices[child]); + root = child; + } + if (!start) + break; + start--; + } + + end = size - 1; + while (end > 0) + { + mz_uint64 child, root = 0; + MZ_SWAP_UINT32(pIndices[end], pIndices[0]); + for (;;) + { + if ((child = (root << 1U) + 1U) >= end) + break; + child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])); + if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child])) + break; + MZ_SWAP_UINT32(pIndices[root], pIndices[child]); + root = child; + } + end--; + } + } + + static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs) + { + mz_int64 cur_file_ofs; + mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; + mz_uint8 *pBuf = (mz_uint8 *)buf_u32; + + /* Basic sanity checks - reject files which are too small */ + if (pZip->m_archive_size < record_size) + return MZ_FALSE; + + /* Find the record by scanning the file from the end towards the beginning. */ + cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0); + for (;;) + { + int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs); + + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n) + return MZ_FALSE; + + for (i = n - 4; i >= 0; --i) + { + mz_uint s = MZ_READ_LE32(pBuf + i); + if (s == record_sig) + { + if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size) + break; + } + } + + if (i >= 0) + { + cur_file_ofs += i; + break; + } + + /* Give up if we've searched the entire file, or we've gone back "too far" (~64kb) */ + if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= ((mz_uint64)(MZ_UINT16_MAX) + record_size))) + return MZ_FALSE; + + cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0); + } + + *pOfs = cur_file_ofs; + return MZ_TRUE; + } + + static mz_bool mz_zip_reader_eocd64_valid(mz_zip_archive *pZip, uint64_t offset, uint8_t *buf) + { + 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) + { + if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) + { + return MZ_TRUE; + } + } + + return MZ_FALSE; + } + + static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags) + { + mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0; + mz_uint64 cdir_ofs = 0, eocd_ofs = 0, archive_ofs = 0; + mz_int64 cur_file_ofs = 0; + const mz_uint8 *p; + + mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; + mz_uint8 *pBuf = (mz_uint8 *)buf_u32; + mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0); + mz_uint32 zip64_end_of_central_dir_locator_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32; + + mz_uint32 zip64_end_of_central_dir_header_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pZip64_end_of_central_dir = (mz_uint8 *)zip64_end_of_central_dir_header_u32; + + mz_uint64 zip64_end_of_central_dir_ofs = 0; + + /* 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. */ + if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR); + + eocd_ofs = cur_file_ofs; + /* Read and verify the end of central directory record. */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) + { + 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) + { + if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) + { + pZip->m_pState->m_zip64 = MZ_TRUE; + } + } + } + + if (pZip->m_pState->m_zip64) + { + /* Try locating the EOCD64 right before the EOCD64 locator. This works even + * when the effective start of the zip header is not yet known. */ + if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + zip64_end_of_central_dir_ofs = cur_file_ofs - + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE - + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE; + + if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, + pZip64_end_of_central_dir)) + { + /* That failed, try reading where the locator tells us to. */ + zip64_end_of_central_dir_ofs = MZ_READ_LE64( + pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS); + + if (zip64_end_of_central_dir_ofs > + (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs, + pZip64_end_of_central_dir)) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + } + } + + pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS); + cdir_entries_on_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); + num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS); + cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS); + cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS); + cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS); + + if (pZip->m_pState->m_zip64) + { + mz_uint32 zip64_total_num_of_disks = MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS); + mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS); + 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); + 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); + mz_uint64 zip64_size_of_central_directory = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS); + + if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (zip64_total_num_of_disks != 1U) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + /* Check for miniz's practical limits */ + if (zip64_cdir_total_entries > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries; + + if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + cdir_entries_on_this_disk = (mz_uint32)zip64_cdir_total_entries_on_this_disk; + + /* Check for miniz's current practical limits (sorry, this should be enough for millions of files) */ + if (zip64_size_of_central_directory > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + cdir_size = (mz_uint32)zip64_size_of_central_directory; + + num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS); + + cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS); + + cdir_ofs = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS); + } + + if (pZip->m_total_files != cdir_entries_on_this_disk) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1))) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (cdir_size < (mz_uint64)pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (eocd_ofs < cdir_ofs + cdir_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + /* The end of central dir follows the central dir, unless the zip file has + * some trailing data (e.g. it is appended to an executable file). */ + archive_ofs = eocd_ofs - (cdir_ofs + cdir_size); + if (pZip->m_pState->m_zip64) + { + if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + archive_ofs -= MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE; + } + + /* Update the archive start position, but only if not specified. */ + if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE || pZip->m_zip_type == MZ_ZIP_TYPE_CFILE || + pZip->m_zip_type == MZ_ZIP_TYPE_USER) && pZip->m_pState->m_file_archive_start_ofs == 0) + { + pZip->m_pState->m_file_archive_start_ofs = archive_ofs; + pZip->m_archive_size -= archive_ofs; + } + + pZip->m_central_directory_file_ofs = cdir_ofs; + + if (pZip->m_total_files) + { + mz_uint i, n; + /* 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. */ + if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) || + (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if (sort_central_dir) + { + if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + /* Now create an index into the central directory file records, do some basic sanity checking on each record */ + p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p; + for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) + { + mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size; + mz_uint64 comp_size, decomp_size, local_header_ofs; + + if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + 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); + + if (sort_central_dir) + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i; + + comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); + local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); + filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); + + if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && + (ext_data_size) && + (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX)) + { + /* Attempt to find zip64 extended information field in the entry's extra data */ + mz_uint32 extra_size_remaining = ext_data_size; + + if (extra_size_remaining) + { + const mz_uint8 *pExtra_data; + void *buf = NULL; + + if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > n) + { + buf = MZ_MALLOC(ext_data_size); + if (buf == NULL) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + 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) + { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + pExtra_data = (mz_uint8 *)buf; + } + else + { + pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size; + } + + do + { + mz_uint32 field_id; + mz_uint32 field_data_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + + if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) + { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) + { + /* 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). */ + pZip->m_pState->m_zip64 = MZ_TRUE; + pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE; + break; + } + + pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; + extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; + } while (extra_size_remaining); + + MZ_FREE(buf); + } + } + + /* I've seen archives that aren't marked as zip64 that uses zip64 ext data, argh */ + if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) + { + if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS); + if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1))) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (comp_size != MZ_UINT32_MAX) + { + 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) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + 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) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + n -= total_header_size; + p += total_header_size; + } + } + + if (sort_central_dir) + mz_zip_reader_sort_central_dir_offsets_by_filename(pZip); + + return MZ_TRUE; + } + + void mz_zip_zero_struct(mz_zip_archive *pZip) + { + if (pZip) + MZ_CLEAR_PTR(pZip); + } + + static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error) + { + mz_bool status = MZ_TRUE; + + if (!pZip) + return MZ_FALSE; + + if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) + { + if (set_last_error) + pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER; + + return MZ_FALSE; + } + + if (pZip->m_pState) + { + mz_zip_internal_state *pState = pZip->m_pState; + pZip->m_pState = NULL; + + mz_zip_array_clear(pZip, &pState->m_central_dir); + mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); + mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); + +#ifndef MINIZ_NO_STDIO + if (pState->m_pFile) + { + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) + { + if (MZ_FCLOSE(pState->m_pFile) == EOF) + { + if (set_last_error) + pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED; + status = MZ_FALSE; + } + } + pState->m_pFile = NULL; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + } + pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; + + return status; + } + + mz_bool mz_zip_reader_end(mz_zip_archive *pZip) + { + return mz_zip_reader_end_internal(pZip, MZ_TRUE); + } + mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags) + { + if ((!pZip) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_USER; + pZip->m_archive_size = size; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) + { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; + } + + static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n) + { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n); + memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s); + return s; + } + + mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags) + { + if (!pMem) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY; + pZip->m_archive_size = size; + pZip->m_pRead = mz_zip_mem_read_func; + pZip->m_pIO_opaque = pZip; + pZip->m_pNeeds_keepalive = NULL; + +#ifdef __cplusplus + pZip->m_pState->m_pMem = const_cast(pMem); +#else + pZip->m_pState->m_pMem = (void *)pMem; +#endif + + pZip->m_pState->m_mem_size = size; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) + { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; + } + +#ifndef MINIZ_NO_STDIO + static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n) + { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile); + + file_ofs += pZip->m_pState->m_file_archive_start_ofs; + + 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)))) + return 0; + + return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile); + } + + mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags) + { + return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0); + } + + 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) + { + mz_uint64 file_size; + MZ_FILE *pFile; + + if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE))) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_READ_ALLOW_WRITING ) ? "r+b" : "rb"); + if (!pFile) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + file_size = archive_size; + if (!file_size) + { + if (MZ_FSEEK64(pFile, 0, SEEK_END)) + { + MZ_FCLOSE(pFile); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + } + + file_size = MZ_FTELL64(pFile); + } + + /* TODO: Better sanity check archive_size and the # of actual remaining bytes */ + + if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + { + MZ_FCLOSE(pFile); + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + } + + if (!mz_zip_reader_init_internal(pZip, flags)) + { + MZ_FCLOSE(pFile); + return MZ_FALSE; + } + + pZip->m_zip_type = MZ_ZIP_TYPE_FILE; + pZip->m_pRead = mz_zip_file_read_func; + pZip->m_pIO_opaque = pZip; + pZip->m_pState->m_pFile = pFile; + pZip->m_archive_size = file_size; + pZip->m_pState->m_file_archive_start_ofs = file_start_ofs; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) + { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; + } + + mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags) + { + mz_uint64 cur_file_ofs; + + if ((!pZip) || (!pFile)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + cur_file_ofs = MZ_FTELL64(pFile); + + if (!archive_size) + { + if (MZ_FSEEK64(pFile, 0, SEEK_END)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + + archive_size = MZ_FTELL64(pFile) - cur_file_ofs; + + if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + } + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_CFILE; + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + pZip->m_pState->m_pFile = pFile; + pZip->m_archive_size = archive_size; + pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) + { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; + } + +#endif /* #ifndef MINIZ_NO_STDIO */ + + static MZ_FORCEINLINE const mz_uint8 *mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index) + { + if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) + return NULL; + 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)); + } + + mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index) + { + mz_uint m_bit_flag; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + return (m_bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0; + } + + mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index) + { + mz_uint bit_flag; + mz_uint method; + + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); + bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + + if ((method != 0) && (method != MZ_DEFLATED)) + { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + return MZ_FALSE; + } + + if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) + { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + return MZ_FALSE; + } + + if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG) + { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + return MZ_FALSE; + } + + return MZ_TRUE; + } + + mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index) + { + mz_uint filename_len, attribute_mapping_id, external_attr; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + if (filename_len) + { + if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/') + return MZ_TRUE; + } + + /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */ + /* 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. */ + /* FIXME: Remove this check? Is it necessary - we already check the filename. */ + attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8; + (void)attribute_mapping_id; + + external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); + if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0) + { + return MZ_TRUE; + } + + return MZ_FALSE; + } + + 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) + { + mz_uint n; + const mz_uint8 *p = pCentral_dir_header; + + if (pFound_zip64_extra_data) + *pFound_zip64_extra_data = MZ_FALSE; + + if ((!p) || (!pStat)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Extract fields from the central directory record. */ + pStat->m_file_index = file_index; + pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index); + pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS); + pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS); + pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); +#ifndef MINIZ_NO_TIME + 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)); +#endif + pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS); + pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); + pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS); + pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); + pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); + + /* Copy as much of the filename and comment as possible. */ + n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1); + memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); + pStat->m_filename[n] = '\0'; + + n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS); + n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1); + pStat->m_comment_size = n; + 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); + pStat->m_comment[n] = '\0'; + + /* Set some flags for convienance */ + pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index); + pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index); + pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index); + + /* See if we need to read any zip64 extended information fields. */ + /* 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). */ + if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), pStat->m_local_header_ofs) == MZ_UINT32_MAX) + { + /* Attempt to find zip64 extended information field in the entry's extra data */ + mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); + + if (extra_size_remaining) + { + const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + + do + { + mz_uint32 field_id; + mz_uint32 field_data_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + + if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) + { + const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2; + mz_uint32 field_data_remaining = field_data_size; + + if (pFound_zip64_extra_data) + *pFound_zip64_extra_data = MZ_TRUE; + + if (pStat->m_uncomp_size == MZ_UINT32_MAX) + { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_uncomp_size = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + field_data_remaining -= sizeof(mz_uint64); + } + + if (pStat->m_comp_size == MZ_UINT32_MAX) + { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_comp_size = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + field_data_remaining -= sizeof(mz_uint64); + } + + if (pStat->m_local_header_ofs == MZ_UINT32_MAX) + { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_local_header_ofs = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + field_data_remaining -= sizeof(mz_uint64); + } + + break; + } + + pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; + extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; + } while (extra_size_remaining); + } + } + + return MZ_TRUE; + } + + static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags) + { + mz_uint i; + if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE) + return 0 == memcmp(pA, pB, len); + for (i = 0; i < len; ++i) + if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) + return MZ_FALSE; + return MZ_TRUE; + } + + 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) + { + 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; + mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS); + mz_uint8 l = 0, r = 0; + pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pE = pL + MZ_MIN(l_len, r_len); + while (pL < pE) + { + if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) + break; + pL++; + pR++; + } + return (pL == pE) ? (int)(l_len - r_len) : (l - r); + } + + static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex) + { + mz_zip_internal_state *pState = pZip->m_pState; + const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; + const mz_zip_array *pCentral_dir = &pState->m_central_dir; + mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0); + const mz_uint32 size = pZip->m_total_files; + const mz_uint filename_len = (mz_uint)strlen(pFilename); + + if (pIndex) + *pIndex = 0; + + if (size) + { + /* yes I could use uint32_t's, but then we would have to add some special case checks in the loop, argh, and */ + /* honestly the major expense here on 32-bit CPU's will still be the filename compare */ + mz_int64 l = 0, h = (mz_int64)size - 1; + + while (l <= h) + { + mz_int64 m = l + ((h - l) >> 1); + mz_uint32 file_index = pIndices[(mz_uint32)m]; + + int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, file_index, pFilename, filename_len); + if (!comp) + { + if (pIndex) + *pIndex = file_index; + return MZ_TRUE; + } + else if (comp < 0) + l = m + 1; + else + h = m - 1; + } + } + + return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); + } + + int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags) + { + mz_uint32 index; + if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index)) + return -1; + else + return (int)index; + } + + mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex) + { + mz_uint file_index; + size_t name_len, comment_len; + + if (pIndex) + *pIndex = 0; + + if ((!pZip) || (!pZip->m_pState) || (!pName)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* See if we can use a binary search */ + if (((pZip->m_pState->m_init_flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) && + (pZip->m_zip_mode == MZ_ZIP_MODE_READING) && + ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) + { + return mz_zip_locate_file_binary_search(pZip, pName, pIndex); + } + + /* Locate the entry by scanning the entire central directory */ + name_len = strlen(pName); + if (name_len > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + comment_len = pComment ? strlen(pComment) : 0; + if (comment_len > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + for (file_index = 0; file_index < pZip->m_total_files; file_index++) + { + 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)); + mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS); + const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + if (filename_len < name_len) + continue; + if (comment_len) + { + 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); + const char *pFile_comment = pFilename + filename_len + file_extra_len; + if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags))) + continue; + } + if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) + { + int ofs = filename_len - 1; + do + { + if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':')) + break; + } while (--ofs >= 0); + ofs++; + pFilename += ofs; + filename_len -= ofs; + } + if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags))) + { + if (pIndex) + *pIndex = file_index; + return MZ_TRUE; + } + } + + return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); + } + + 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) + { + int status = TINFL_STATUS_DONE; + mz_uint64 needed_size, cur_file_ofs, comp_remaining, out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail; + mz_zip_archive_file_stat file_stat; + void *pRead_buf; + mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + tinfl_decompressor inflator; + + if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (st) + { + file_stat = *st; + } + else if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + /* A directory or zero length file */ + if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + /* Ensure supplied output buffer is large enough. */ + needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size; + if (buf_size < needed_size) + return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL); + + /* Read and parse the local directory entry. */ + cur_file_ofs = file_stat.m_local_header_ofs; + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + 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); + if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) + { + /* The file is stored or the caller has requested the compressed data. */ + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, (size_t)needed_size) != needed_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0) + { + if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) + return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); + } +#endif + + return MZ_TRUE; + } + + /* Decompress the file either directly from memory or from a file input buffer. */ + tinfl_init(&inflator); + + if (pZip->m_pState->m_pMem) + { + /* Read directly from the archive in memory. */ + pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs; + read_buf_size = read_buf_avail = file_stat.m_comp_size; + comp_remaining = 0; + } + else if (pUser_read_buf) + { + /* Use a user provided read buffer. */ + if (!user_read_buf_size) + return MZ_FALSE; + pRead_buf = (mz_uint8 *)pUser_read_buf; + read_buf_size = user_read_buf_size; + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } + else + { + /* Temporarily allocate a read buffer. */ + read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } + + do + { + /* The size_t cast here should be OK because we've verified that the output buffer is >= file_stat.m_uncomp_size above */ + size_t in_buf_size, out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs); + if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) + { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) + { + status = TINFL_STATUS_FAILED; + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + break; + } + cur_file_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + read_buf_ofs = 0; + } + in_buf_size = (size_t)read_buf_avail; + 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)); + read_buf_avail -= in_buf_size; + read_buf_ofs += in_buf_size; + out_buf_ofs += out_buf_size; + } while (status == TINFL_STATUS_NEEDS_MORE_INPUT); + + if (status == TINFL_STATUS_DONE) + { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (out_buf_ofs != file_stat.m_uncomp_size) + { + mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) + { + mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); + status = TINFL_STATUS_FAILED; + } +#endif + } + + if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf)) + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + + return status == TINFL_STATUS_DONE; + } + + 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) + { + return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL); + } + + 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) + { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return MZ_FALSE; + return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL); + } + + 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) + { + return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, NULL, 0, NULL); + } + + 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) + { + return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0); + } + + void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags) + { + mz_zip_archive_file_stat file_stat; + mz_uint64 alloc_size; + void *pBuf; + + if (pSize) + *pSize = 0; + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return NULL; + + alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size; + if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF)) + { + mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + return NULL; + } + + if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size))) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return NULL; + } + + if (!mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, (size_t)alloc_size, flags, NULL, 0, &file_stat)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return NULL; + } + + if (pSize) + *pSize = (size_t)alloc_size; + return pBuf; + } + + void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags) + { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + { + if (pSize) + *pSize = 0; + return MZ_FALSE; + } + return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags); + } + + 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) + { + int status = TINFL_STATUS_DONE; +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + mz_uint file_crc32 = MZ_CRC32_INIT; +#endif + mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs; + mz_zip_archive_file_stat file_stat; + void *pRead_buf = NULL; + void *pWrite_buf = NULL; + mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + + if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + /* A directory or zero length file */ + if ((file_stat.m_is_directory) || (!file_stat.m_comp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + /* 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) */ + cur_file_ofs = file_stat.m_local_header_ofs; + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + 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); + if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + /* Decompress the file either directly from memory or from a file input buffer. */ + if (pZip->m_pState->m_pMem) + { + pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs; + read_buf_size = read_buf_avail = file_stat.m_comp_size; + comp_remaining = 0; + } + else + { + read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } + + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) + { + /* The file is stored or the caller has requested the compressed data. */ + if (pZip->m_pState->m_pMem) + { + if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size) + { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + } + else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + { +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size); +#endif + } + + cur_file_ofs += file_stat.m_comp_size; + out_buf_ofs += file_stat.m_comp_size; + comp_remaining = 0; + } + else + { + while (comp_remaining) + { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + { + file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail); + } +#endif + + if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) + { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + + cur_file_ofs += read_buf_avail; + out_buf_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + } + } + } + else + { + tinfl_decompressor inflator; + tinfl_init(&inflator); + + if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE))) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + status = TINFL_STATUS_FAILED; + } + else + { + do + { + mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) + { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + cur_file_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + read_buf_ofs = 0; + } + + in_buf_size = (size_t)read_buf_avail; + 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); + read_buf_avail -= in_buf_size; + read_buf_ofs += in_buf_size; + + if (out_buf_size) + { + if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size) + { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size); +#endif + if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size) + { + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + } + } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT)); + } + } + + if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) + { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (out_buf_ofs != file_stat.m_uncomp_size) + { + mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (file_crc32 != file_stat.m_crc32) + { + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + status = TINFL_STATUS_FAILED; + } +#endif + } + + if (!pZip->m_pState->m_pMem) + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + + if (pWrite_buf) + pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf); + + return status == TINFL_STATUS_DONE; + } + + 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) + { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags); + } + + mz_zip_reader_extract_iter_state *mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags) + { + mz_zip_reader_extract_iter_state *pState; + mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + + /* Argument sanity check */ + if ((!pZip) || (!pZip->m_pState)) + return NULL; + + /* Allocate an iterator status structure */ + pState = (mz_zip_reader_extract_iter_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state)); + if (!pState) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return NULL; + } + + /* Fetch file details */ + if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Encryption and patch files are not supported. */ + 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)) + { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED)) + { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Init state - save args */ + pState->pZip = pZip; + pState->flags = flags; + + /* Init state - reset variables to defaults */ + pState->status = TINFL_STATUS_DONE; +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + pState->file_crc32 = MZ_CRC32_INIT; +#endif + pState->read_buf_ofs = 0; + pState->out_buf_ofs = 0; + pState->pRead_buf = NULL; + pState->pWrite_buf = NULL; + pState->out_blk_remain = 0; + + /* Read and parse the local directory entry. */ + pState->cur_file_ofs = pState->file_stat.m_local_header_ofs; + 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) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + 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); + if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Decompress the file either directly from memory or from a file input buffer. */ + if (pZip->m_pState->m_pMem) + { + pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs; + pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size; + pState->comp_remaining = pState->file_stat.m_comp_size; + } + else + { + if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) + { + /* Decompression required, therefore intermediate read buffer required */ + pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size))) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + } + else + { + /* Decompression not required - we will be reading directly into user buffer, no temp buf required */ + pState->read_buf_size = 0; + } + pState->read_buf_avail = 0; + pState->comp_remaining = pState->file_stat.m_comp_size; + } + + if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))) + { + /* Decompression required, init decompressor */ + tinfl_init(&pState->inflator); + + /* Allocate write buffer */ + if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE))) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + if (pState->pRead_buf) + pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + } + + return pState; + } + + mz_zip_reader_extract_iter_state *mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags) + { + mz_uint32 file_index; + + /* Locate file index by name */ + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return NULL; + + /* Construct iterator */ + return mz_zip_reader_extract_iter_new(pZip, file_index, flags); + } + + size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state *pState, void *pvBuf, size_t buf_size) + { + size_t copied_to_caller = 0; + + /* Argument sanity check */ + if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) + return 0; + + if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)) + { + /* The file is stored or the caller has requested the compressed data, calc amount to return. */ + copied_to_caller = (size_t)MZ_MIN(buf_size, pState->comp_remaining); + + /* Zip is in memory....or requires reading from a file? */ + if (pState->pZip->m_pState->m_pMem) + { + /* Copy data to caller's buffer */ + memcpy(pvBuf, pState->pRead_buf, copied_to_caller); + pState->pRead_buf = ((mz_uint8 *)pState->pRead_buf) + copied_to_caller; + } + else + { + /* Read directly into caller's buffer */ + if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller) + { + /* Failed to read all that was asked for, flag failure and alert user */ + mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); + pState->status = TINFL_STATUS_FAILED; + copied_to_caller = 0; + } + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + /* Compute CRC if not returning compressed data only */ + if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller); +#endif + + /* Advance offsets, dec counters */ + pState->cur_file_ofs += copied_to_caller; + pState->out_buf_ofs += copied_to_caller; + pState->comp_remaining -= copied_to_caller; + } + else + { + do + { + /* Calc ptr to write buffer - given current output pos and block size */ + mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + + /* Calc max output size - given current output pos and block size */ + size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + + if (!pState->out_blk_remain) + { + /* Read more data from file if none available (and reading from file) */ + if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem)) + { + /* Calc read size */ + pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining); + 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) + { + mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); + pState->status = TINFL_STATUS_FAILED; + break; + } + + /* Advance offsets, dec counters */ + pState->cur_file_ofs += pState->read_buf_avail; + pState->comp_remaining -= pState->read_buf_avail; + pState->read_buf_ofs = 0; + } + + /* Perform decompression */ + in_buf_size = (size_t)pState->read_buf_avail; + 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); + pState->read_buf_avail -= in_buf_size; + pState->read_buf_ofs += in_buf_size; + + /* Update current output block size remaining */ + pState->out_blk_remain = out_buf_size; + } + + if (pState->out_blk_remain) + { + /* Calc amount to return. */ + size_t to_copy = MZ_MIN((buf_size - copied_to_caller), pState->out_blk_remain); + + /* Copy data to caller's buffer */ + memcpy((mz_uint8 *)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy); + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + /* Perform CRC */ + pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy); +#endif + + /* Decrement data consumed from block */ + pState->out_blk_remain -= to_copy; + + /* Inc output offset, while performing sanity check */ + if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size) + { + mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); + pState->status = TINFL_STATUS_FAILED; + break; + } + + /* Increment counter of data copied to caller */ + copied_to_caller += to_copy; + } + } while ((copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT))); + } + + /* Return how many bytes were copied into user buffer */ + return copied_to_caller; + } + + mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state *pState) + { + int status; + + /* Argument sanity check */ + if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState)) + return MZ_FALSE; + + /* Was decompression completed and requested? */ + if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) + { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size) + { + mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + pState->status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (pState->file_crc32 != pState->file_stat.m_crc32) + { + mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); + pState->status = TINFL_STATUS_FAILED; + } +#endif + } + + /* Free buffers */ + if (!pState->pZip->m_pState->m_pMem) + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf); + if (pState->pWrite_buf) + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf); + + /* Save status */ + status = pState->status; + + /* Free context */ + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState); + + return status == TINFL_STATUS_DONE; + } + +#ifndef MINIZ_NO_STDIO + static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n) + { + (void)ofs; + + return MZ_FWRITE(pBuf, 1, n, (MZ_FILE *)pOpaque); + } + + mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags) + { + mz_bool status; + mz_zip_archive_file_stat file_stat; + MZ_FILE *pFile; + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + if ((file_stat.m_is_directory) || (!file_stat.m_is_supported)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + pFile = MZ_FOPEN(pDst_filename, "wb"); + if (!pFile) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags); + + if (MZ_FCLOSE(pFile) == EOF) + { + if (status) + mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); + + status = MZ_FALSE; + } + +#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) + if (status) + mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time); +#endif + + return status; + } + + mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags) + { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags); + } + + mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags) + { + mz_zip_archive_file_stat file_stat; + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + if ((file_stat.m_is_directory) || (!file_stat.m_is_supported)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags); + } + + mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags) + { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags); + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n) + { + mz_uint32 *p = (mz_uint32 *)pOpaque; + (void)file_ofs; + *p = (mz_uint32)mz_crc32(*p, (const mz_uint8 *)pBuf, n); + return n; + } + + mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags) + { + mz_zip_archive_file_stat file_stat; + mz_zip_internal_state *pState; + const mz_uint8 *pCentral_dir_header; + mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE; + mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE; + mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + mz_uint64 local_header_ofs = 0; + mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32; + mz_uint64 local_header_comp_size, local_header_uncomp_size; + mz_uint32 uncomp_crc32 = MZ_CRC32_INIT; + mz_bool has_data_descriptor; + mz_uint32 local_header_bit_flags; + + mz_zip_array file_data_array; + mz_zip_array_init(&file_data_array, 1); + + if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (file_index > pZip->m_total_files) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + pCentral_dir_header = mz_zip_get_cdh(pZip, file_index); + + if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir)) + return MZ_FALSE; + + /* A directory or zero length file */ + if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + if (file_stat.m_is_encrypted) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports stored and deflate. */ + if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + if (!file_stat.m_is_supported) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + /* Read and parse the local directory entry. */ + local_header_ofs = file_stat.m_local_header_ofs; + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS); + local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS); + local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS); + local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS); + local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS); + has_data_descriptor = (local_header_bit_flags & 8) != 0; + + if (local_header_filename_len != strlen(file_stat.m_filename)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + 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) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE)) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + goto handle_failure; + } + + if (local_header_filename_len) + { + 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) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + /* 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. */ + if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0) + { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } + + if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) + { + mz_uint32 extra_size_remaining = local_header_extra_len; + const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p; + + 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) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + do + { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) + { + const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32); + + if (field_data_size < sizeof(mz_uint64) * 2) + { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data); + local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); + + found_zip64_ext_data_in_ldir = MZ_TRUE; + break; + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + } + + /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */ + /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */ + if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32)) + { + mz_uint8 descriptor_buf[32]; + mz_bool has_id; + const mz_uint8 *pSrc; + mz_uint32 file_crc32; + mz_uint64 comp_size = 0, uncomp_size = 0; + + mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4; + + 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)) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID); + pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf; + + file_crc32 = MZ_READ_LE32(pSrc); + + if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) + { + comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32)); + uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64)); + } + else + { + comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32)); + uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32)); + } + + if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size)) + { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } + else + { + 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)) + { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } + + mz_zip_array_clear(pZip, &file_data_array); + + if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0) + { + if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0)) + return MZ_FALSE; + + /* 1 more check to be sure, although the extract checks too. */ + if (uncomp_crc32 != file_stat.m_crc32) + { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + return MZ_FALSE; + } + } + + return MZ_TRUE; + + handle_failure: + mz_zip_array_clear(pZip, &file_data_array); + return MZ_FALSE; + } + + mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags) + { + mz_zip_internal_state *pState; + mz_uint32 i; + + if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + /* Basic sanity checks */ + if (!pState->m_zip64) + { + if (pZip->m_total_files > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + if (pZip->m_archive_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } + else + { + if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } + + for (i = 0; i < pZip->m_total_files; i++) + { + if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags) + { + mz_uint32 found_index; + mz_zip_archive_file_stat stat; + + if (!mz_zip_reader_file_stat(pZip, i, &stat)) + return MZ_FALSE; + + if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index)) + return MZ_FALSE; + + /* 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) */ + if (found_index != i) + return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + } + + if (!mz_zip_validate_file(pZip, i, flags)) + return MZ_FALSE; + } + + return MZ_TRUE; + } + + mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr) + { + mz_bool success = MZ_TRUE; + mz_zip_archive zip; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + if ((!pMem) || (!size)) + { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + mz_zip_zero_struct(&zip); + + if (!mz_zip_reader_init_mem(&zip, pMem, size, flags)) + { + if (pErr) + *pErr = zip.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_validate_archive(&zip, flags)) + { + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (!mz_zip_reader_end_internal(&zip, success)) + { + if (!actual_err) + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (pErr) + *pErr = actual_err; + + return success; + } + +#ifndef MINIZ_NO_STDIO + mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr) + { + mz_bool success = MZ_TRUE; + mz_zip_archive zip; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + if (!pFilename) + { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + mz_zip_zero_struct(&zip); + + if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0)) + { + if (pErr) + *pErr = zip.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_validate_archive(&zip, flags)) + { + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (!mz_zip_reader_end_internal(&zip, success)) + { + if (!actual_err) + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (pErr) + *pErr = actual_err; + + return success; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + /* ------------------- .ZIP archive writing */ + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + + static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v) + { + p[0] = (mz_uint8)v; + p[1] = (mz_uint8)(v >> 8); + } + static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v) + { + p[0] = (mz_uint8)v; + p[1] = (mz_uint8)(v >> 8); + p[2] = (mz_uint8)(v >> 16); + p[3] = (mz_uint8)(v >> 24); + } + static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v) + { + mz_write_le32(p, (mz_uint32)v); + mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32)); + } + +#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) +#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) +#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) + + static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n) + { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_zip_internal_state *pState = pZip->m_pState; + mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size); + + if (!n) + return 0; + + /* An allocation this big is likely to just fail on 32-bit systems, so don't even go there. */ + if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + return 0; + } + + if (new_size > pState->m_mem_capacity) + { + void *pNew_block; + size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity); + + while (new_capacity < new_size) + new_capacity *= 2; + + if (NULL == (pNew_block = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity))) + { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return 0; + } + + pState->m_pMem = pNew_block; + pState->m_mem_capacity = new_capacity; + } + memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n); + pState->m_mem_size = (size_t)new_size; + return n; + } + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error) + { + mz_zip_internal_state *pState; + mz_bool status = MZ_TRUE; + + 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))) + { + if (set_last_error) + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + pState = pZip->m_pState; + pZip->m_pState = NULL; + mz_zip_array_clear(pZip, &pState->m_central_dir); + mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); + mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); + +#ifndef MINIZ_NO_STDIO + if (pState->m_pFile) + { + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) + { + if (MZ_FCLOSE(pState->m_pFile) == EOF) + { + if (set_last_error) + mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); + status = MZ_FALSE; + } + } + + pState->m_pFile = NULL; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem); + pState->m_pMem = NULL; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; + return status; + } + + mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags) + { + mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0; + + if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + { + if (!pZip->m_pRead) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + if (pZip->m_file_offset_alignment) + { + /* Ensure user specified file offset alignment is a power of 2. */ + if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + if (!pZip->m_pAlloc) + pZip->m_pAlloc = miniz_def_alloc_func; + if (!pZip->m_pFree) + pZip->m_pFree = miniz_def_free_func; + if (!pZip->m_pRealloc) + pZip->m_pRealloc = miniz_def_realloc_func; + + pZip->m_archive_size = existing_size; + pZip->m_central_directory_file_ofs = 0; + pZip->m_total_files = 0; + + if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); + + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32)); + + pZip->m_pState->m_zip64 = zip64; + pZip->m_pState->m_zip64_has_extended_info_fields = zip64; + + pZip->m_zip_type = MZ_ZIP_TYPE_USER; + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING; + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size) + { + return mz_zip_writer_init_v2(pZip, existing_size, 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) + { + pZip->m_pWrite = mz_zip_heap_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_mem_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_HEAP; + + if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning))) + { + if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size))) + { + mz_zip_writer_end_internal(pZip, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + pZip->m_pState->m_mem_capacity = initial_allocation_size; + } + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size) + { + return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0); + } + +#ifndef MINIZ_NO_STDIO + static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n) + { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile); + + file_ofs += pZip->m_pState->m_file_archive_start_ofs; + + 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)))) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + return 0; + } + + return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile); + } + + mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning) + { + return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0); + } + + 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) + { + MZ_FILE *pFile; + + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) + return MZ_FALSE; + + if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb"))) + { + mz_zip_writer_end(pZip); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + } + + pZip->m_pState->m_pFile = pFile; + pZip->m_zip_type = MZ_ZIP_TYPE_FILE; + + if (size_to_reserve_at_beginning) + { + mz_uint64 cur_ofs = 0; + char buf[4096]; + + MZ_CLEAR_ARR(buf); + + do + { + size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning); + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n) + { + mz_zip_writer_end(pZip); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_ofs += n; + size_to_reserve_at_beginning -= n; + } while (size_to_reserve_at_beginning); + } + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags) + { + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, 0, flags)) + return MZ_FALSE; + + pZip->m_pState->m_pFile = pFile; + pZip->m_pState->m_file_archive_start_ofs = MZ_FTELL64(pZip->m_pState->m_pFile); + pZip->m_zip_type = MZ_ZIP_TYPE_CFILE; + + return MZ_TRUE; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags) + { + mz_zip_internal_state *pState; + + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (flags & MZ_ZIP_FLAG_WRITE_ZIP64) + { + /* 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?) */ + if (!pZip->m_pState->m_zip64) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + /* No sense in trying to write to an archive that's already at the support max size */ + if (pZip->m_pState->m_zip64) + { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + else + { + if (pZip->m_total_files == MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + } + + pState = pZip->m_pState; + + if (pState->m_pFile) + { +#ifdef MINIZ_NO_STDIO + (void)pFilename; + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); +#else + if (pZip->m_pIO_opaque != pZip) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE && + !(flags & MZ_ZIP_FLAG_READ_ALLOW_WRITING) ) + { + if (!pFilename) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */ + if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile))) + { + /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */ + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + } + } + + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; +#endif /* #ifdef MINIZ_NO_STDIO */ + } + else if (pState->m_pMem) + { + /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */ + if (pZip->m_pIO_opaque != pZip) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState->m_mem_capacity = pState->m_mem_size; + pZip->m_pWrite = mz_zip_heap_write_func; + pZip->m_pNeeds_keepalive = NULL; + } + /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */ + else if (!pZip->m_pWrite) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Start writing new files at the archive's current central directory location. */ + /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */ + pZip->m_archive_size = pZip->m_central_directory_file_ofs; + pZip->m_central_directory_file_ofs = 0; + + /* Clear the sorted central dir offsets, they aren't useful or maintained now. */ + /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */ + /* TODO: We could easily maintain the sorted central directory offsets. */ + mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets); + + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING; + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename) + { + return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0); + } + + /* TODO: pArchive_name is a terrible name here! */ + 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) + { + return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0); + } + + typedef struct + { + mz_zip_archive *m_pZip; + mz_uint64 m_cur_archive_file_ofs; + mz_uint64 m_comp_size; + } mz_zip_writer_add_state; + + static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser) + { + mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser; + if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, pState->m_cur_archive_file_ofs, pBuf, len) != len) + return MZ_FALSE; + + pState->m_cur_archive_file_ofs += len; + pState->m_comp_size += len; + return MZ_TRUE; + } + +#define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2) +#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3) + 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) + { + mz_uint8 *pDst = pBuf; + mz_uint32 field_size = 0; + + MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID); + MZ_WRITE_LE16(pDst + 2, 0); + pDst += sizeof(mz_uint16) * 2; + + if (pUncomp_size) + { + MZ_WRITE_LE64(pDst, *pUncomp_size); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + if (pComp_size) + { + MZ_WRITE_LE64(pDst, *pComp_size); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + if (pLocal_header_ofs) + { + MZ_WRITE_LE64(pDst, *pLocal_header_ofs); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + MZ_WRITE_LE16(pBuf + 2, field_size); + + return (mz_uint32)(pDst - pBuf); + } + + 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) + { + (void)pZip; + memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size); + return MZ_TRUE; + } + + static mz_bool mz_zip_writer_create_central_dir_header(mz_zip_archive *pZip, mz_uint8 *pDst, + mz_uint16 filename_size, mz_uint16 extra_size, mz_uint16 comment_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, + mz_uint64 local_header_ofs, mz_uint32 ext_attributes) + { + (void)pZip; + memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_MIN(comp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_MIN(uncomp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_MIN(local_header_ofs, MZ_UINT32_MAX)); + return MZ_TRUE; + } + + static mz_bool mz_zip_writer_add_to_central_dir(mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, + const void *pExtra, mz_uint16 extra_size, const void *pComment, mz_uint16 comment_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, + mz_uint64 local_header_ofs, mz_uint32 ext_attributes, + const char *user_extra_data, mz_uint user_extra_data_len) + { + mz_zip_internal_state *pState = pZip->m_pState; + mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size; + size_t orig_central_dir_size = pState->m_central_dir.m_size; + mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE]; + + if (!pZip->m_pState->m_zip64) + { + if (local_header_ofs > 0xFFFFFFFF) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + } + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, filename_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, extra_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, user_extra_data_len)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, comment_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, ¢ral_dir_ofs, 1))) + { + /* Try to resize the central directory array back into its original state. */ + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + return MZ_TRUE; + } + + static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name) + { + /* 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. */ + if (*pArchive_name == '/') + return MZ_FALSE; + + /* Making sure the name does not contain drive letters or DOS style backward slashes is the responsibility of the program using miniz*/ + + return MZ_TRUE; + } + + static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip) + { + mz_uint32 n; + if (!pZip->m_file_offset_alignment) + return 0; + n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1)); + return (mz_uint)((pZip->m_file_offset_alignment - n) & (pZip->m_file_offset_alignment - 1)); + } + + static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n) + { + char buf[4096]; + memset(buf, 0, MZ_MIN(sizeof(buf), n)); + while (n) + { + mz_uint32 s = MZ_MIN(sizeof(buf), n); + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_file_ofs += s; + n -= s; + } + return MZ_TRUE; + } + + 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, + mz_uint64 uncomp_size, mz_uint32 uncomp_crc32) + { + 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); + } + + 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, + mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, + const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len) + { + mz_uint16 method = 0, dos_time = 0, dos_date = 0; + mz_uint level, ext_attributes = 0, num_alignment_padding_bytes; + mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0; + size_t archive_name_size; + mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE]; + tdefl_compressor *pComp = NULL; + mz_bool store_data_uncompressed; + mz_zip_internal_state *pState; + mz_uint8 *pExtra_data = NULL; + mz_uint32 extra_size = 0; + mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; + mz_uint16 bit_flags = 0; + + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + + if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) + bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; + + if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) + bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; + + level = level_and_flags & 0xF; + store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)); + + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if (pState->m_zip64) + { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + else + { + if (pZip->m_total_files == MZ_UINT16_MAX) + { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */ + } + if (((mz_uint64)buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF)) + { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + + if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + +#ifndef MINIZ_NO_TIME + if (last_modified != NULL) + { + mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date); + } + else + { + MZ_TIME_T cur_time; + time(&cur_time); + mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date); + } +#else + (void)last_modified; +#endif /* #ifndef MINIZ_NO_TIME */ + + if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + { + uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size); + uncomp_size = buf_size; + if (uncomp_size <= 3) + { + level = 0; + store_data_uncompressed = MZ_TRUE; + } + } + + archive_name_size = strlen(pArchive_name); + if (archive_name_size > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + if (!pState->m_zip64) + { + /* Bail early if the archive would obviously become too large */ + 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 + user_extra_data_central_len + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF) + { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + + if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/')) + { + /* Set DOS Subdirectory attribute bit. */ + ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG; + + /* Subdirectories cannot contain data. */ + if ((buf_size) || (uncomp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + /* 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.) */ + 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))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if ((!store_data_uncompressed) && (buf_size)) + { + if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return MZ_FALSE; + } + + local_dir_header_ofs += num_alignment_padding_bytes; + if (pZip->m_file_offset_alignment) + { + MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0); + } + cur_archive_file_ofs += num_alignment_padding_bytes; + + MZ_CLEAR_ARR(local_dir_header); + + if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + { + method = MZ_DEFLATED; + } + + if (pState->m_zip64) + { + if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) + { + pExtra_data = extra_data; + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_archive_file_ofs += archive_name_size; + + if (pExtra_data != NULL) + { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += extra_size; + } + } + else + { + if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_archive_file_ofs += archive_name_size; + } + + if (user_extra_data_len > 0) + { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += user_extra_data_len; + } + + if (store_data_uncompressed) + { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += buf_size; + comp_size = buf_size; + } + else if (buf_size) + { + mz_zip_writer_add_state state; + + state.m_pZip = pZip; + state.m_cur_archive_file_ofs = cur_archive_file_ofs; + state.m_comp_size = 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) || + (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED); + } + + comp_size = state.m_comp_size; + cur_archive_file_ofs = state.m_cur_archive_file_ofs; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + pComp = NULL; + + if (uncomp_size) + { + mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64]; + mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32; + + MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR); + + MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID); + MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32); + if (pExtra_data == NULL) + { + if (comp_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(local_dir_footer + 8, comp_size); + MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size); + } + else + { + MZ_WRITE_LE64(local_dir_footer + 8, comp_size); + MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size); + local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64; + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size) + return MZ_FALSE; + + cur_archive_file_ofs += local_dir_footer_size; + } + + if (pExtra_data != NULL) + { + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + 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, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes, + user_extra_data_central, user_extra_data_central_len)) + return MZ_FALSE; + + pZip->m_total_files++; + pZip->m_archive_size = cur_archive_file_ofs; + + return MZ_TRUE; + } + + 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, + const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len) + { + mz_uint16 gen_flags; + mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes; + mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0; + mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = 0, comp_size = 0; + size_t archive_name_size; + mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE]; + mz_uint8 *pExtra_data = NULL; + mz_uint32 extra_size = 0; + mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; + mz_zip_internal_state *pState; + mz_uint64 file_ofs = 0, cur_archive_header_file_ofs; + + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + level = level_and_flags & 0xF; + + gen_flags = (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) ? 0 : MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; + + if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) + gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; + + /* Sanity checks */ + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX)) + { + /* Source file is too large for non-zip64 */ + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + pState->m_zip64 = MZ_TRUE; + } + + /* We could support this, but why? */ + if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + if (pState->m_zip64) + { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + else + { + if (pZip->m_total_files == MZ_UINT16_MAX) + { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */ + } + } + + archive_name_size = strlen(pArchive_name); + if (archive_name_size > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + if (!pState->m_zip64) + { + /* Bail early if the archive would obviously become too large */ + 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) + { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + +#ifndef MINIZ_NO_TIME + if (pFile_time) + { + mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date); + } +#else + (void)pFile_time; +#endif + + if (max_size <= 3) + level = 0; + + if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes)) + { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += num_alignment_padding_bytes; + local_dir_header_ofs = cur_archive_file_ofs; + + if (pZip->m_file_offset_alignment) + { + MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0); + } + + if (max_size && level) + { + method = MZ_DEFLATED; + } + + MZ_CLEAR_ARR(local_dir_header); + if (pState->m_zip64) + { + if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) + { + pExtra_data = extra_data; + if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + else + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, NULL, + NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) + { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += archive_name_size; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += extra_size; + } + else + { + if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size) + { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += archive_name_size; + } + + if (user_extra_data_len > 0) + { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += user_extra_data_len; + } + + if (max_size) + { + void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE); + if (!pRead_buf) + { + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!level) + { + while (1) + { + size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE); + if (n == 0) + break; + + if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + file_ofs += n; + uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n); + cur_archive_file_ofs += n; + } + uncomp_size = file_ofs; + comp_size = uncomp_size; + } + else + { + mz_bool result = MZ_FALSE; + mz_zip_writer_add_state state; + tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor)); + if (!pComp) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + state.m_pZip = pZip; + state.m_cur_archive_file_ofs = cur_archive_file_ofs; + state.m_comp_size = 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) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + } + + for (;;) + { + tdefl_status status; + tdefl_flush flush = TDEFL_NO_FLUSH; + + size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE); + if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) + { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + break; + } + + file_ofs += n; + uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n); + + if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque)) + flush = TDEFL_FULL_FLUSH; + + if (n == 0) + flush = TDEFL_FINISH; + + status = tdefl_compress_buffer(pComp, pRead_buf, n, flush); + if (status == TDEFL_STATUS_DONE) + { + result = MZ_TRUE; + break; + } + else if (status != TDEFL_STATUS_OKAY) + { + mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED); + break; + } + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + + if (!result) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return MZ_FALSE; + } + + uncomp_size = file_ofs; + comp_size = state.m_comp_size; + cur_archive_file_ofs = state.m_cur_archive_file_ofs; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + } + + if (!(level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)) + { + mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64]; + mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32; + + MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID); + MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32); + if (pExtra_data == NULL) + { + if (comp_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(local_dir_footer + 8, comp_size); + MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size); + } + else + { + MZ_WRITE_LE64(local_dir_footer + 8, comp_size); + MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size); + local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64; + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size) + return MZ_FALSE; + + cur_archive_file_ofs += local_dir_footer_size; + } + + if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) + { + if (pExtra_data != NULL) + { + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + 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), + (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size, + (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : comp_size, + uncomp_crc32, method, gen_flags, dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + cur_archive_header_file_ofs = local_dir_header_ofs; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + if (pExtra_data != NULL) + { + cur_archive_header_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, pArchive_name, archive_name_size) != archive_name_size) + { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_header_file_ofs += archive_name_size; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, extra_data, extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_header_file_ofs += extra_size; + } + } + + if (pExtra_data != NULL) + { + extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + 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, + uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes, + user_extra_data_central, user_extra_data_central_len)) + return MZ_FALSE; + + pZip->m_total_files++; + pZip->m_archive_size = cur_archive_file_ofs; + + return MZ_TRUE; + } + +#ifndef MINIZ_NO_STDIO + + static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n) + { + MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pSrc_file); + + if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET)))) + return 0; + + return MZ_FREAD(pBuf, 1, n, pSrc_file); + } + + 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, + const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len) + { + 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, + user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len); + } + + 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) + { + MZ_FILE *pSrc_file = NULL; + mz_uint64 uncomp_size = 0; + MZ_TIME_T file_modified_time; + MZ_TIME_T *pFile_time = NULL; + mz_bool status; + + memset(&file_modified_time, 0, sizeof(file_modified_time)); + +#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) + pFile_time = &file_modified_time; + if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED); +#endif + + pSrc_file = MZ_FOPEN(pSrc_filename, "rb"); + if (!pSrc_file) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + MZ_FSEEK64(pSrc_file, 0, SEEK_END); + uncomp_size = MZ_FTELL64(pSrc_file); + MZ_FSEEK64(pSrc_file, 0, SEEK_SET); + + 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); + + MZ_FCLOSE(pSrc_file); + + return status; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + 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) + { + /* + 64 should be enough for any new zip64 data */ + if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + mz_zip_array_resize(pZip, pNew_ext, 0, MZ_FALSE); + + if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) + { + mz_uint8 new_ext_block[64]; + mz_uint8 *pDst = new_ext_block; + mz_write_le16(pDst, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID); + mz_write_le16(pDst + sizeof(mz_uint16), 0); + pDst += sizeof(mz_uint16) * 2; + + if (pUncomp_size) + { + mz_write_le64(pDst, *pUncomp_size); + pDst += sizeof(mz_uint64); + } + + if (pComp_size) + { + mz_write_le64(pDst, *pComp_size); + pDst += sizeof(mz_uint64); + } + + if (pLocal_header_ofs) + { + mz_write_le64(pDst, *pLocal_header_ofs); + pDst += sizeof(mz_uint64); + } + + if (pDisk_start) + { + mz_write_le32(pDst, *pDisk_start); + pDst += sizeof(mz_uint32); + } + + mz_write_le16(new_ext_block + sizeof(mz_uint16), (mz_uint16)((pDst - new_ext_block) - sizeof(mz_uint16) * 2)); + + if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, pDst - new_ext_block)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if ((pExt) && (ext_len)) + { + mz_uint32 extra_size_remaining = ext_len; + const mz_uint8 *pExtra_data = pExt; + + do + { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) + { + if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, field_total_size)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + } + + return MZ_TRUE; + } + + /* TODO: This func is now pretty freakin complex due to zip64, split it up? */ + mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index) + { + mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size; + mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs; + mz_uint64 cur_src_file_ofs, cur_dst_file_ofs; + mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE]; + size_t orig_central_dir_size; + mz_zip_internal_state *pState; + void *pBuf; + const mz_uint8 *pSrc_central_header; + mz_zip_archive_file_stat src_file_stat; + mz_uint32 src_filename_len, src_comment_len, src_ext_len; + mz_uint32 local_header_filename_size, local_header_extra_len; + mz_uint64 local_header_comp_size, local_header_uncomp_size; + mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE; + + /* Sanity checks */ + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */ + if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Get pointer to the source central dir header and crack it */ + if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index))) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS); + src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS); + src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS); + src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len; + + /* 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) */ + if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + if (!pState->m_zip64) + { + if (pZip->m_total_files == MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + else + { + /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */ + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + + if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL)) + return MZ_FALSE; + + cur_src_file_ofs = src_file_stat.m_local_header_ofs; + cur_dst_file_ofs = pZip->m_archive_size; + + /* Read the source archive's local dir header */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE; + + /* Compute the total size we need to copy (filename+extra data+compressed data) */ + local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS); + local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS); + local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS); + src_archive_bytes_remaining = src_file_stat.m_comp_size + local_header_filename_size + local_header_extra_len; + + /* Try to find a zip64 extended information field */ + if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX))) + { + mz_zip_array file_data_array; + const mz_uint8 *pExtra_data; + mz_uint32 extra_size_remaining = local_header_extra_len; + + mz_zip_array_init(&file_data_array, 1); + if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE)) + { + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + 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) + { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + pExtra_data = (const mz_uint8 *)file_data_array.m_p; + + do + { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) + { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) + { + const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32); + + if (field_data_size < sizeof(mz_uint64) * 2) + { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data); + local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */ + + found_zip64_ext_data_in_ldir = MZ_TRUE; + break; + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + + mz_zip_array_clear(pZip, &file_data_array); + } + + if (!pState->m_zip64) + { + /* 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). */ + /* We also check when the archive is finalized so this doesn't need to be perfect. */ + 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) + + 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; + + if (approx_new_archive_size >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } + + /* Write dest archive padding */ + if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes)) + return MZ_FALSE; + + cur_dst_file_ofs += num_alignment_padding_bytes; + + local_dir_header_ofs = cur_dst_file_ofs; + if (pZip->m_file_offset_alignment) + { + MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0); + } + + /* 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 */ + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE; + + /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */ + 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))))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + while (src_archive_bytes_remaining) + { + n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining); + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + cur_src_file_ofs += n; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_dst_file_ofs += n; + + src_archive_bytes_remaining -= n; + } + + /* Now deal with the optional data descriptor */ + bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS); + if (bit_flags & 8) + { + /* Copy data descriptor */ + if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir)) + { + /* src is zip64, dest must be zip64 */ + + /* name uint32_t's */ + /* id 1 (optional in zip64?) */ + /* crc 1 */ + /* comp_size 2 */ + /* uncomp_size 2 */ + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6)) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5); + } + else + { + /* src is NOT zip64 */ + mz_bool has_id; + + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID); + + if (pZip->m_pState->m_zip64) + { + /* dest is zip64, so upgrade the data descriptor */ + const mz_uint8 *pSrc_descriptor = (const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0); + const mz_uint32 src_crc32 = MZ_READ_LE32(pSrc_descriptor); + const mz_uint64 src_comp_size = MZ_READ_LE32(pSrc_descriptor + sizeof(mz_uint32)); + const mz_uint64 src_uncomp_size = MZ_READ_LE32(pSrc_descriptor + 2 * sizeof(mz_uint32)); + + mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID); + mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32); + mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size); + mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size); + + n = sizeof(mz_uint32) * 6; + } + else + { + /* dest is NOT zip64, just copy it as-is */ + n = sizeof(mz_uint32) * (has_id ? 4 : 3); + } + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) + { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_src_file_ofs += n; + cur_dst_file_ofs += n; + } + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + + /* Finally, add the new central dir header */ + orig_central_dir_size = pState->m_central_dir.m_size; + + memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE); + + if (pState->m_zip64) + { + /* 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. */ + const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len; + mz_zip_array new_ext_block; + + mz_zip_array_init(&new_ext_block, sizeof(mz_uint8)); + + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_UINT32_MAX); + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_UINT32_MAX); + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_UINT32_MAX); + + 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)) + { + mz_zip_array_clear(pZip, &new_ext_block); + return MZ_FALSE; + } + + MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size); + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) + { + mz_zip_array_clear(pZip, &new_ext_block); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len)) + { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size)) + { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + 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)) + { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + mz_zip_array_clear(pZip, &new_ext_block); + } + else + { + /* sanity checks */ + if (cur_dst_file_ofs > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + if (local_dir_header_ofs >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs); + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + 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)) + { + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + } + + /* This shouldn't trigger unless we screwed up during the initial sanity checks */ + if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) + { + /* TODO: Support central dirs >= 32-bits in size */ + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + } + + n = (mz_uint32)orig_central_dir_size; + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1)) + { + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + pZip->m_total_files++; + pZip->m_archive_size = cur_dst_file_ofs; + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip) + { + mz_zip_internal_state *pState; + mz_uint64 central_dir_ofs, central_dir_size; + mz_uint8 hdr[256]; + + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if (pState->m_zip64) + { + if ((mz_uint64)pState->m_central_dir.m_size >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + else + { + 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)) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + + central_dir_ofs = 0; + central_dir_size = 0; + if (pZip->m_total_files) + { + /* Write central directory */ + central_dir_ofs = pZip->m_archive_size; + central_dir_size = pState->m_central_dir.m_size; + pZip->m_central_directory_file_ofs = central_dir_ofs; + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += central_dir_size; + } + + if (pState->m_zip64) + { + /* Write zip64 end of central directory header */ + mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size; + + MZ_CLEAR_ARR(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG); + 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)); + MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */ + MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, pZip->m_total_files); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, pZip->m_total_files); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs); + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE; + + /* Write zip64 end of central directory locator */ + MZ_CLEAR_ARR(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1); + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE; + } + + /* Write end of central directory record */ + MZ_CLEAR_ARR(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); + MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_size)); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_MIN(MZ_UINT32_MAX, central_dir_ofs)); + + 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) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + +#ifndef MINIZ_NO_STDIO + if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); +#endif /* #ifndef MINIZ_NO_STDIO */ + + pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE; + + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED; + return MZ_TRUE; + } + + mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize) + { + if ((!ppBuf) || (!pSize)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + *ppBuf = NULL; + *pSize = 0; + + if ((!pZip) || (!pZip->m_pState)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (pZip->m_pWrite != mz_zip_heap_write_func) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_finalize_archive(pZip)) + return MZ_FALSE; + + *ppBuf = pZip->m_pState->m_pMem; + *pSize = pZip->m_pState->m_mem_size; + pZip->m_pState->m_pMem = NULL; + pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0; + + return MZ_TRUE; + } + + mz_bool mz_zip_writer_end(mz_zip_archive *pZip) + { + return mz_zip_writer_end_internal(pZip, MZ_TRUE); + } +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */ + +#ifndef MINIZ_NO_STDIO + 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) + { + 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); + } + + 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) + { + mz_bool status, created_new_archive = MZ_FALSE; + mz_zip_archive zip_archive; + struct MZ_FILE_STAT_STRUCT file_stat; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + mz_zip_zero_struct(&zip_archive); + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + + if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION)) + { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) + { + if (pErr) + *pErr = MZ_ZIP_INVALID_FILENAME; + return MZ_FALSE; + } + + /* 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. */ + /* So be sure to compile with _LARGEFILE64_SOURCE 1 */ + if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0) + { + /* Create a new archive. */ + if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags)) + { + if (pErr) + *pErr = zip_archive.m_last_error; + return MZ_FALSE; + } + + created_new_archive = MZ_TRUE; + } + else + { + /* Append to an existing archive. */ + 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)) + { + if (pErr) + *pErr = zip_archive.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_READ_ALLOW_WRITING)) + { + if (pErr) + *pErr = zip_archive.m_last_error; + + mz_zip_reader_end_internal(&zip_archive, MZ_FALSE); + + return MZ_FALSE; + } + } + + status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0); + actual_err = zip_archive.m_last_error; + + /* 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.) */ + if (!mz_zip_writer_finalize_archive(&zip_archive)) + { + if (!actual_err) + actual_err = zip_archive.m_last_error; + + status = MZ_FALSE; + } + + if (!mz_zip_writer_end_internal(&zip_archive, status)) + { + if (!actual_err) + actual_err = zip_archive.m_last_error; + + status = MZ_FALSE; + } + + if ((!status) && (created_new_archive)) + { + /* It's a new archive and something went wrong, so just delete it. */ + int ignoredStatus = MZ_DELETE_FILE(pZip_filename); + (void)ignoredStatus; + } + + if (pErr) + *pErr = actual_err; + + return status; + } + + 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) + { + mz_uint32 file_index; + mz_zip_archive zip_archive; + void *p = NULL; + + if (pSize) + *pSize = 0; + + if ((!pZip_filename) || (!pArchive_name)) + { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + + return NULL; + } + + mz_zip_zero_struct(&zip_archive); + if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0)) + { + if (pErr) + *pErr = zip_archive.m_last_error; + + return NULL; + } + + if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index)) + { + p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags); + } + + mz_zip_reader_end_internal(&zip_archive, p != NULL); + + if (pErr) + *pErr = zip_archive.m_last_error; + + return p; + } + + void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags) + { + return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL); + } + +#endif /* #ifndef MINIZ_NO_STDIO */ + +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */ + + /* ------------------- Misc utils */ + + mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip) + { + return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID; + } + + mz_zip_type mz_zip_get_type(mz_zip_archive *pZip) + { + return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID; + } + + mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num) + { + mz_zip_error prev_err; + + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + prev_err = pZip->m_last_error; + + pZip->m_last_error = err_num; + return prev_err; + } + + mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip) + { + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + return pZip->m_last_error; + } + + mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip) + { + return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR); + } + + mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip) + { + mz_zip_error prev_err; + + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + prev_err = pZip->m_last_error; + + pZip->m_last_error = MZ_ZIP_NO_ERROR; + return prev_err; + } + + const char *mz_zip_get_error_string(mz_zip_error mz_err) + { + switch (mz_err) + { + case MZ_ZIP_NO_ERROR: + return "no error"; + case MZ_ZIP_UNDEFINED_ERROR: + return "undefined error"; + case MZ_ZIP_TOO_MANY_FILES: + return "too many files"; + case MZ_ZIP_FILE_TOO_LARGE: + return "file too large"; + case MZ_ZIP_UNSUPPORTED_METHOD: + return "unsupported method"; + case MZ_ZIP_UNSUPPORTED_ENCRYPTION: + return "unsupported encryption"; + case MZ_ZIP_UNSUPPORTED_FEATURE: + return "unsupported feature"; + case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR: + return "failed finding central directory"; + case MZ_ZIP_NOT_AN_ARCHIVE: + return "not a ZIP archive"; + case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED: + return "invalid header or archive is corrupted"; + case MZ_ZIP_UNSUPPORTED_MULTIDISK: + return "unsupported multidisk archive"; + case MZ_ZIP_DECOMPRESSION_FAILED: + return "decompression failed or archive is corrupted"; + case MZ_ZIP_COMPRESSION_FAILED: + return "compression failed"; + case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE: + return "unexpected decompressed size"; + case MZ_ZIP_CRC_CHECK_FAILED: + return "CRC-32 check failed"; + case MZ_ZIP_UNSUPPORTED_CDIR_SIZE: + return "unsupported central directory size"; + case MZ_ZIP_ALLOC_FAILED: + return "allocation failed"; + case MZ_ZIP_FILE_OPEN_FAILED: + return "file open failed"; + case MZ_ZIP_FILE_CREATE_FAILED: + return "file create failed"; + case MZ_ZIP_FILE_WRITE_FAILED: + return "file write failed"; + case MZ_ZIP_FILE_READ_FAILED: + return "file read failed"; + case MZ_ZIP_FILE_CLOSE_FAILED: + return "file close failed"; + case MZ_ZIP_FILE_SEEK_FAILED: + return "file seek failed"; + case MZ_ZIP_FILE_STAT_FAILED: + return "file stat failed"; + case MZ_ZIP_INVALID_PARAMETER: + return "invalid parameter"; + case MZ_ZIP_INVALID_FILENAME: + return "invalid filename"; + case MZ_ZIP_BUF_TOO_SMALL: + return "buffer too small"; + case MZ_ZIP_INTERNAL_ERROR: + return "internal error"; + case MZ_ZIP_FILE_NOT_FOUND: + return "file not found"; + case MZ_ZIP_ARCHIVE_TOO_LARGE: + return "archive is too large"; + case MZ_ZIP_VALIDATION_FAILED: + return "validation failed"; + case MZ_ZIP_WRITE_CALLBACK_FAILED: + return "write callback failed"; + case MZ_ZIP_TOTAL_ERRORS: + return "total errors"; + default: + break; + } + + return "unknown error"; + } + + /* Note: Just because the archive is not zip64 doesn't necessarily mean it doesn't have Zip64 extended information extra field, argh. */ + mz_bool mz_zip_is_zip64(mz_zip_archive *pZip) + { + if ((!pZip) || (!pZip->m_pState)) + return MZ_FALSE; + + return pZip->m_pState->m_zip64; + } + + size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip) + { + if ((!pZip) || (!pZip->m_pState)) + return 0; + + return pZip->m_pState->m_central_dir.m_size; + } + + mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip) + { + return pZip ? pZip->m_total_files : 0; + } + + mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip) + { + if (!pZip) + return 0; + return pZip->m_archive_size; + } + + mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip) + { + if ((!pZip) || (!pZip->m_pState)) + return 0; + return pZip->m_pState->m_file_archive_start_ofs; + } + + MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip) + { + if ((!pZip) || (!pZip->m_pState)) + return 0; + return pZip->m_pState->m_pFile; + } + + size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n) + { + if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n); + } + + mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size) + { + mz_uint n; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) + { + if (filename_buf_size) + pFilename[0] = '\0'; + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return 0; + } + n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + if (filename_buf_size) + { + n = MZ_MIN(n, filename_buf_size - 1); + memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); + pFilename[n] = '\0'; + } + return n + 1; + } + + mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat) + { + return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL); + } + + mz_bool mz_zip_end(mz_zip_archive *pZip) + { + if (!pZip) + return MZ_FALSE; + + if (pZip->m_zip_mode == MZ_ZIP_MODE_READING) + return mz_zip_reader_end(pZip); +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)) + return mz_zip_writer_end(pZip); +#endif + + return MZ_FALSE; + } + +#ifdef __cplusplus +} +#endif + +#endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/ \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/platform/win/HttpDownloaderWin.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/platform/win/HttpDownloaderWin.cpp new file mode 100644 index 0000000..7c07c26 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/platform/win/HttpDownloaderWin.cpp @@ -0,0 +1,10 @@ +#include + +// WinHttpOpen with proxy Error: +// WinHttpConnect with proxy Error: +// WinHttpOpen Error: +// WinHttpConnect Error: +// WinHttpSendRequest Error: +// WinHttpOpenRequest Error: +// WinHttpReadData Error: +// WebRequestWin::performRequestFromThread caught an exception \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/platform/win/NamedPipe.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/platform/win/NamedPipe.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/randomutils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/randomutils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/timeutils.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libpaceutil/timeutils.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libproxyapp/ProxyAppLoader.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libproxyapp/ProxyAppLoader.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libproxyapp/platform/win/proxyappserverwin.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libproxyapp/platform/win/proxyappserverwin.cpp new file mode 100644 index 0000000..b12983f --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/client/pace/libraries/src/libproxyapp/platform/win/proxyappserverwin.cpp @@ -0,0 +1,40 @@ +#include + +// ProxyApp.getVersion +// ProxyApp.alertUser +// ProxyApp.notifyUser +// ProxyApp.activateAuth +// ProxyApp.deactivateAuth +// ProxyApp.quit +// ProxyApp.checkMinimumEdenVersion +// ProxyApp.getUserAccountList +// ProxyApp.getUserAccountPassword +// ProxyApp.removeUserAccountPassword +// ProxyApp.setDefaultUserAccountId +// ProxyApp.setUserAccountPassword +// ProxyApp_getVersion_result +// ProxyApp_alertUser_result +// ProxyApp_notifyUser_result +// ProxyApp_activateAuth_result +// ProxyApp_deactivateAuth_result +// ProxyApp_checkMinimumEdenVersion_result +// ProxyApp_getUserAccountList_result +// ProxyApp_getUserAccountPassword_result +// ProxyApp_removeUserAccountPassword_result +// ProxyApp_setDefaultUserAccountId_result +// ProxyApp_setUserAccountPassword_result + +// Caught an exception in ProxyAppServerBase::getVersion +// Caught an exception in ProxyAppServerBase::alertUser +// Caught an exception in ProxyAppServerBase::notifyUser +// Caught an exception in ProxyAppServerBase::activateAuth +// Caught an exception in ProxyAppServerBase::deactivateAuth +// Caught an exception in ProxyAppServerBase::checkMinimumEdenVersion +// Caught an exception in ProxyAppServerBase::getUserAccountList +// Caught an exception in ProxyAppServerBase::getUserAccountPassword +// Caught an exception in ProxyAppServerBase::removeUserAccountPassword +// Caught an exception in ProxyAppServerBase::setDefaultUserAccountId +// Caught an exception in ProxyAppServerBase::setUserAccountPassword +// Caught an exception in ProxyAppServerBase::getKeyChainPassword +// Caught an exception in ProxyAppServerBase::removeKeyChainPassword +// Caught an exception in ProxyAppServerBase::setKeyChainPassword \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsActivationInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsActivationInfo.cpp new file mode 100644 index 0000000..5b08236 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsActivationInfo.cpp @@ -0,0 +1,4 @@ +#include + +// acceptableLocations: +// activationDate: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsArrayEntry.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsArrayEntry.cpp new file mode 100644 index 0000000..6966d72 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsArrayEntry.cpp @@ -0,0 +1,4 @@ +#include + +// IMUL ESP.dowrd ptr [RBP + 0x79], 0x3a +// valueBinary: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAssociativeArray.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAssociativeArray.cpp new file mode 100644 index 0000000..b8829f0 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAssociativeArray.cpp @@ -0,0 +1,3 @@ +#include + +// Relation named entries with related object count: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthKey.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthKey.cpp new file mode 100644 index 0000000..5943ac8 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthKey.cpp @@ -0,0 +1,4 @@ +#include + +// algorithmId: +// encrpytedWithId: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthManifestElement.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthManifestElement.cpp new file mode 100644 index 0000000..9a3a5e6 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthManifestElement.cpp @@ -0,0 +1,4 @@ +#include + +// aaSigningEntropy: +// authId: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthRelation.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthRelation.cpp new file mode 100644 index 0000000..f850ad7 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthRelation.cpp @@ -0,0 +1,4 @@ +#include + +// Relation named child with related object ( +// Relation named child has no related object. \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthorization.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthorization.cpp new file mode 100644 index 0000000..f16396d --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsAuthorization.cpp @@ -0,0 +1,3 @@ +#include + +// authType: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorActivationInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorActivationInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorArrayEntry.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorArrayEntry.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAssociativeArray.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAssociativeArray.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthKey.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthKey.cpp new file mode 100644 index 0000000..7cc5f6c --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthKey.cpp @@ -0,0 +1,4 @@ +#include + +// LsLicenseWire::compareWireObjectsEqual +// LsLicenseWire.selfRelation.entityId \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthManifestElement.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthManifestElement.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthRelation.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthRelation.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthorization.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorAuthorization.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorCertificateChain.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorCertificateChain.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorCountLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorCountLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorDatabaseInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorDatabaseInfo.cpp new file mode 100644 index 0000000..7892a66 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorDatabaseInfo.cpp @@ -0,0 +1,4 @@ +#include + +// deleteObject +// flushObject \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorDeveloperBlock.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorDeveloperBlock.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorExpirationWarning.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorExpirationWarning.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorIlokAuth.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorIlokAuth.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorLicense.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorLicense.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorMachineBinding.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorMachineBinding.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorMachineId.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorMachineId.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignature.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignature.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignedDigest.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignedDigest.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignedInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorSignedInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorTimeLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorTimeLimit.cpp new file mode 100644 index 0000000..d6d9ad7 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCachedObjectVectorTimeLimit.cpp @@ -0,0 +1,4 @@ +#include + +// LsAuthorizationWire::compareWireObjectsEqual: +// LsAuthorizationWire.selfRelation.entityId \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCertificateChain.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCertificateChain.cpp new file mode 100644 index 0000000..0ef6e22 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCertificateChain.cpp @@ -0,0 +1,3 @@ +#include + +// chainStructure: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCountLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCountLimit.cpp new file mode 100644 index 0000000..b75189f --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsCountLimit.cpp @@ -0,0 +1,4 @@ +#include + +// counter1CountsUpNotDown +// counter1CurrentCount \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDatabaseInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDatabaseInfo.cpp new file mode 100644 index 0000000..355b15f --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDatabaseInfo.cpp @@ -0,0 +1,4 @@ +#include + +// databaseInfoGuid: +// dateRegistered: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDeveloperBlock.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDeveloperBlock.cpp new file mode 100644 index 0000000..b7ebdb8 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsDeveloperBlock.cpp @@ -0,0 +1,4 @@ +#include + +// countLimited: +// - skipped - \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsActivationInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsActivationInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsArrayEntry.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsArrayEntry.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAssociativeArray.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAssociativeArray.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthKey.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthKey.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthManifestElement.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthManifestElement.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthRelation.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthRelation.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthorization.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsAuthorization.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsCertificationChain.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsCertificationChain.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsCountLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsCountLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsDatabaseInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsDatabaseInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsDeveloperBlock.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsDeveloperBlock.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsExpirationWarning.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsExpirationWarning.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsIlokAuth.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsIlokAuth.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsLicense.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsLicense.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsMachineBinding.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsMachineBinding.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsMachineId.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsMachineId.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignature.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignature.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignedDigest.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignedDigest.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignedInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsSignedInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsTimeLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsEntityUtilsTimeLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsExpirationWarning.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsExpirationWarning.cpp new file mode 100644 index 0000000..fbe24f6 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsExpirationWarning.cpp @@ -0,0 +1,4 @@ +#include + +// combined64BitCounter: +// countLimitIsSet: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsIlokAuth.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsIlokAuth.cpp new file mode 100644 index 0000000..df07b34 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsIlokAuth.cpp @@ -0,0 +1,3 @@ +#include + +// locationIndicator: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsLicense.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsLicense.cpp new file mode 100644 index 0000000..76cd58c --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsLicense.cpp @@ -0,0 +1,4 @@ +#include + +// agreementGuid: +// bindingAlgorithm: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineBinding.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineBinding.cpp new file mode 100644 index 0000000..c03e284 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineBinding.cpp @@ -0,0 +1,4 @@ +#include + +// bindingData: +// bindingId: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineId.Cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineId.Cpp new file mode 100644 index 0000000..cf6bf9a --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsMachineId.Cpp @@ -0,0 +1,4 @@ +#include + +// localizedName: +// nodeName: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorActivationInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorActivationInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorArrayEntry.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorArrayEntry.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAssociativeArray.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAssociativeArray.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthKey.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthKey.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthManifestElement.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthManifestElement.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthRelation.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthRelation.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthorization.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthorization.cpp new file mode 100644 index 0000000..36dbc5e --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorAuthorization.cpp @@ -0,0 +1,4 @@ +#include + +// LsCountLimitWire::compareWireObjectsEqual: +// LsCountLimitWire.selfRelation.entityId \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorCountLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorCountLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorDatabaseInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorDatabaseInfo.cpp new file mode 100644 index 0000000..85a8579 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorDatabaseInfo.cpp @@ -0,0 +1,3 @@ +#include + +// LsMachineIdWire::compareWireObjectsEqual: \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorDeveloperBlock.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorDeveloperBlock.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorExpirationWarning.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorExpirationWarning.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorIlokAuth.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorIlokAuth.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorLicense.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorLicense.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorMachineBinding.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorMachineBinding.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorMachineId.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorMachineId.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignature.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignature.cpp new file mode 100644 index 0000000..b412ce5 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignature.cpp @@ -0,0 +1,3 @@ +#include + +// makes call to DsigSignatureVerifier.cpp \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignedDigest.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignedDigest.cpp new file mode 100644 index 0000000..2625537 --- /dev/null +++ b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignedDigest.cpp @@ -0,0 +1,3 @@ +#include + +// makes call to LsEntityUtilsAuthManifestELement.cpp \ No newline at end of file diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignedInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorSignedInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorTimeLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsObjectRelationVectorTimeLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignature.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignature.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignedDigest.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignedDigest.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignedInfo.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsSignedInfo.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsTimeLimit.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/liblicenseservices/LsTimeLimit.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/libpacelicensedb/LsObjectCacheAutogenerated.cpp b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/libpacelicensedb/LsObjectCacheAutogenerated.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/libpacelicensedb/LsObjectStoreUtilsGenerated.h b/ptx/edenDev/edenDev/jenkins/full/eden/common/paceSources/generated/licenseServices/libpacelicensedb/LsObjectStoreUtilsGenerated.h new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/paceDev/client/thirdPartyLibs/installedWin32/individual/winsparkle/Release/x64/WinSparkle.pdb b/ptx/edenDev/edenDev/paceDev/client/thirdPartyLibs/installedWin32/individual/winsparkle/Release/x64/WinSparkle.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX/PlugIns/NonCore/ChannelStrip/Source/Dynamics/Compressor_Parameters.cpp b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX/PlugIns/NonCore/ChannelStrip/Source/Dynamics/Compressor_Parameters.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Interfaces/AAX_CParameter.h b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Interfaces/AAX_CParameter.h new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Libs/AAXLibrary/source/AAX_CEffectParameters.cpp b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Libs/AAXLibrary/source/AAX_CEffectParameters.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Libs/AAXLibrary/source/AAX_VComponentDescriptor.cpp b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/AAX_SDK/Libs/AAXLibrary/source/AAX_VComponentDescriptor.cpp new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/conan_s/8b4140/1/include/boost-1_83/boost/smart_ptr/intrusive_ptr.hpp b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/conan_s/8b4140/1/include/boost-1_83/boost/smart_ptr/intrusive_ptr.hpp new file mode 100644 index 0000000..338e672 --- /dev/null +++ b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/conan_s/8b4140/1/include/boost-1_83/boost/smart_ptr/intrusive_ptr.hpp @@ -0,0 +1,311 @@ +#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED +#define BOOST_INTRUSIVE_PTR_HPP_INCLUDED + +// +// intrusive_ptr.hpp +// +// Copyright (c) 2001, 2002 Peter Dimov +// +// Distributed under the Boost Software License, Version 1.0. (See +// accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) +// +// See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation. +// + +#include + +#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash +# pragma warning(push) +# pragma warning(disable:4284) // odd return type for operator-> +#endif + +#include +#include +#include + +#include // for std::less + +#if !defined(BOOST_NO_IOSTREAM) +#if !defined(BOOST_NO_IOSFWD) +#include // for std::basic_ostream +#else +#include +#endif +#endif + + +namespace boost +{ + +// +// intrusive_ptr +// +// A smart pointer that uses intrusive reference counting. +// +// Relies on unqualified calls to +// +// void intrusive_ptr_add_ref(T * p); +// void intrusive_ptr_release(T * p); +// +// (p != 0) +// +// The object is responsible for destroying itself. +// + +template class intrusive_ptr +{ +private: + + typedef intrusive_ptr this_type; + +public: + + typedef T element_type; + + intrusive_ptr(): p_(0) + { + } + + intrusive_ptr(T * p, bool add_ref = true): p_(p) + { + if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_); + } + +#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) + + template +#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) + + intrusive_ptr( intrusive_ptr const & rhs, typename detail::sp_enable_if_convertible::type = detail::sp_empty() ) + +#else + + intrusive_ptr( intrusive_ptr const & rhs ) + +#endif + : p_( rhs.get() ) + { + if( p_ != 0 ) intrusive_ptr_add_ref( p_ ); + } + +#endif + + intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_) + { + if(p_ != 0) intrusive_ptr_add_ref(p_); + } + + ~intrusive_ptr() + { + if(p_ != 0) intrusive_ptr_release(p_); + } + +#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) + + template intrusive_ptr & operator=(intrusive_ptr const & rhs) + { + this_type(rhs).swap(*this); + return *this; + } + +#endif + + intrusive_ptr & operator=(intrusive_ptr const & rhs) + { + this_type(rhs).swap(*this); + return *this; + } + + intrusive_ptr & operator=(T * rhs) + { + this_type(rhs).swap(*this); + return *this; + } + + void reset() + { + this_type().swap( *this ); + } + + void reset( T * rhs ) + { + this_type( rhs ).swap( *this ); + } + + T * get() const + { + return p_; + } + + T & operator*() const + { + BOOST_ASSERT( p_ != 0 ); + return *p_; + } + + T * operator->() const + { + BOOST_ASSERT( p_ != 0 ); + return p_; + } + +#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) + + operator bool () const + { + return p_ != 0; + } + +#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) + typedef T * (this_type::*unspecified_bool_type)() const; + + operator unspecified_bool_type() const // never throws + { + return p_ == 0? 0: &this_type::get; + } + +#else + + typedef T * this_type::*unspecified_bool_type; + + operator unspecified_bool_type () const + { + return p_ == 0? 0: &this_type::p_; + } + +#endif + + // operator! is a Borland-specific workaround + bool operator! () const + { + return p_ == 0; + } + + void swap(intrusive_ptr & rhs) + { + T * tmp = p_; + p_ = rhs.p_; + rhs.p_ = tmp; + } + +private: + + T * p_; +}; + +template inline bool operator==(intrusive_ptr const & a, intrusive_ptr const & b) +{ + return a.get() == b.get(); +} + +template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b) +{ + return a.get() != b.get(); +} + +template inline bool operator==(intrusive_ptr const & a, U * b) +{ + return a.get() == b; +} + +template inline bool operator!=(intrusive_ptr const & a, U * b) +{ + return a.get() != b; +} + +template inline bool operator==(T * a, intrusive_ptr const & b) +{ + return a == b.get(); +} + +template inline bool operator!=(T * a, intrusive_ptr const & b) +{ + return a != b.get(); +} + +#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 + +// Resolve the ambiguity between our op!= and the one in rel_ops + +template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b) +{ + return a.get() != b.get(); +} + +#endif + +template inline bool operator<(intrusive_ptr const & a, intrusive_ptr const & b) +{ + return std::less()(a.get(), b.get()); +} + +template void swap(intrusive_ptr & lhs, intrusive_ptr & rhs) +{ + lhs.swap(rhs); +} + +// mem_fn support + +template T * get_pointer(intrusive_ptr const & p) +{ + return p.get(); +} + +template intrusive_ptr static_pointer_cast(intrusive_ptr const & p) +{ + return static_cast(p.get()); +} + +template intrusive_ptr const_pointer_cast(intrusive_ptr const & p) +{ + return const_cast(p.get()); +} + +template intrusive_ptr dynamic_pointer_cast(intrusive_ptr const & p) +{ + return dynamic_cast(p.get()); +} + +// operator<< + +#if !defined(BOOST_NO_IOSTREAM) + +#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) && (__GNUC__ < 3) ) + +template std::ostream & operator<< (std::ostream & os, intrusive_ptr const & p) +{ + os << p.get(); + return os; +} + +#else + +// in STLport's no-iostreams mode no iostream symbols can be used +#ifndef _STLP_NO_IOSTREAMS + +# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT) +// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL +using std::basic_ostream; +template basic_ostream & operator<< (basic_ostream & os, intrusive_ptr const & p) +# else +template std::basic_ostream & operator<< (std::basic_ostream & os, intrusive_ptr const & p) +# endif +{ + os << p.get(); + return os; +} + +#endif // _STLP_NO_IOSTREAMS + +#endif // __GNUC__ < 3 + +#endif // !defined(BOOST_NO_IOSTREAM) + +} // namespace boost + +#ifdef BOOST_MSVC +# pragma warning(pop) +#endif + +#endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/x64/Release/pdb/BDM.pdb b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/x64/Release/pdb/BDM.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/x64/Release/pdb/ProToolsApp.pdb b/ptx/edenDev/edenDev/ws/PT/release/2025/r1/WinBag/x64/Release/pdb/ProToolsApp.pdb new file mode 100644 index 0000000..e69de29 diff --git a/ptx/imhex/protools-ptx.hexproj b/ptx/imhex/protools-ptx.hexproj new file mode 100644 index 0000000..2ec6604 Binary files /dev/null and b/ptx/imhex/protools-ptx.hexproj differ diff --git a/ptx/samples/Untitled [RAWBASE].ptx b/ptx/samples/Untitled [RAWBASE].ptx new file mode 100644 index 0000000..f422526 Binary files /dev/null and b/ptx/samples/Untitled [RAWBASE].ptx differ diff --git a/ptx/samples/Untitled2.ptx b/ptx/samples/Untitled2.ptx new file mode 100644 index 0000000..91d84f9 Binary files /dev/null and b/ptx/samples/Untitled2.ptx differ diff --git a/ptx/strings-ptx.txt b/ptx/strings-ptx.txt new file mode 100644 index 0000000..6986a4e --- /dev/null +++ b/ptx/strings-ptx.txt @@ -0,0 +1,2869 @@ + 1 0010111100101011 + 2d Pro Tools HD + 4d 12.5.0 + 58 Release + 64 Pro Tools Session File + 80 Windows + bf Info #1 + ca Info #2 + d5 Info #3 + e0 Info #4 + eb Info #5 + 119 Music + 122 Multitracks + 131 =My Multis= + 140 PROTOOLS + 14c Untitled2 + 159 zpmmZVBBghywMBBB + 16d Untitled2.ptx + 209 Users + 212 macintosh + 21f AppData + 22a Roaming + 235 Avid + 23d Pro Tools + 24a Last Used.pio + 5aa Z + 664 Z + 71e n tbdi + 8e0 Snap1 + 8e9 Snap2 + 8f2 Snap3 + 8fb Snap4 + 904 Snap5 + 90d Snap6 + 916 Snap7 + 91f Snap8 + 928 Snap9 + 931 Snap10 + 93b Snap11 + 945 Snap12 + 94f Snap13 + 959 Snap14 + 963 Snap15 + 96d Snap16 + 977 Snap17 + 981 Snap18 + 98b Snap19 + 995 Snap20 + 99f Snap21 + 9a9 Snap22 + 9b3 Snap23 + 9bd Snap24 + 9c7 Snap25 + 9d1 Snap26 + 9db Snap27 + 9e5 Snap28 + 9ef Snap29 + 9f9 Snap30 + a03 Snap31 + a0d Snap32 + a17 Snap33 + a21 Snap34 + a2b Snap35 + a35 Snap36 + a3f Snap37 + a49 Snap38 + a53 Snap39 + a5d Snap40 + a67 Snap41 + a71 Snap42 + a7b Snap43 + a85 Snap44 + a8f Snap45 + a99 Snap46 + aa3 Snap47 + aad Snap48Z + b06 0| 0| 060 + b18 0:00.001 + b27 00:00:00:00.01 + b3a 0+00.01 + b4a 1 + bd7 24:00:00:00Z + c90 PolyphonicigiDPleFyloP + cb1 com.avid.aax.fela.2solaZ + ce4 A 1-2 + d3f $G~q + d47 Out 1-2 + d83 Out 1-2 + dbf MON L/R + dfb Front Left / Front Right + e48 MON L/R + e84 Built-in Output 1-2 + ecc MON L/R + f08 MON L/R + f44 MON L/R + f80 MON L/R + fbc Front Left / Front Right + 1009 Pg{~f?{|2]gfbgf2#? + 1051 S2#? + 106e 4:%% + 108b S2#? + 11b1 "'hY + 11c2 &hYH + 1210 &hYH + 1231 B~sfw2Dw`p + 1285 B~sfw2Dw`p<^ + 12b8 %hYH + 12d9 B~sfw2Dw`p<@ + 12fb y*hY + 130c %hYH + 132d Q]_B + 1349 I,hY + 137b Q]_B<^ + 13a7 I,hYH + 13c9 Q]_B<@ + 13e5 Z-hY + 13f5 I,hYH + 1417 B}afAfsqya + 1439 UShY + 146b B}afAfsqya<^ + 149d UShYH + 14bf B}afAfsqya<@ + 14e1 6PhY + 14f1 UShYH + 1513 VsVg + 1562 VsVg + 1590 VhYH + 15b1 VsVg + 15df VhYH + 1600 Qz}`gaV}gpw + 1623 3UhY + 1655 Qz}`gaV}gpw<^ + 1688 3UhYH + 16aa Qz}`gaV}gpw<@ + 16dd 3UhYH + 16ff Pga2#!?#& + 1720 -XhY + 1752 Pga2#! + 177e -XhYH + 17a0 Pga2#& + 17bc 4YhY + 17cc -XhYH + 17ee Zs`2Afsqya + 1810 k_hY + 1842 Zs`2Afsqya<^ + 1874 k_hYH + 1896 Zs`2Afsqya<@ + 18b8 r\hY + 18c8 k_hYH + 18ea Pga2#%?#* + 193d Pga2#% + 1959 0ChY + 196a BhYH + 198b Pga2#* + 19b8 BhYH + 1a26 D]J<^ + 1a41 `FhY + 1a52 FhYH + 1a73 D]J<@ + 1a9f FhYH + 1ac0 Pga2 #? + 1ae1 UEhY + 1b13 Pga2 # + 1b3f UEhYH + 1b61 Pga2 + 1b7d 3JhY + 1b8d UEhYH + 1baf TsafVw~sk + 1c02 TsafVw~sk<^ + 1c34 HhYH + 1c55 TsafVw~sk<@ + 1c87 HhYH + 1ca8 _]\2^=@ + 1d05 6Ulc + 1d0d ]gf2#? + 1d49 ]gf2#? + 1d85 _]\2^=@ + 1dc1 T`}|f2^wtf2=2T`}|f2@{uzf + 1e0e _]\2^=@ + 1e4a Pg{~f?{|2]gfbgf2#? + 1e92 _]\2^=@ + 1ece _]\2^=@ + 1ef6 _]\2^=@<^ + 1f47 _]\2^=@<@ + 1fff `$$$$ + 2005 $$$} + 200f V~%$"$$$% + 2019 $$$$ + 201e $~'$`$$$& + 2028 &$'$$$ + 2030 v%$$$:$ + 2038 $%$$$$$ + 2040 $$$} + 204a V$$$$ + 2050 $$$} + 205a V~%$"$$$% + 2064 $$$$ + 2069 $~'$l$$$& + 2073 &%!$$$`AHE]&$$$;$ + 2088 %$$$$$ + 208f $$$} + 2099 V$$$$$$$$$$$$$$$$~%$"$$$% + 20b3 $$$$ + 20b8 $~'$l$$$& + 20c2 &$#$$$`AHE] + 20ce h%$$$;$ + 20d6 $%$$$$$ + 20de $$$} + 20e8 V$$$$ + 20ee $$$} + 20f8 V~%$"$$$% + 2102 $$$$ + 2107 $~'$l$$$& + 2111 &$#$$$`AHE] + 211d v%$$$ + 2125 $%$$$$$ + 212d $$$} + 2137 V$$$$ + 213d $$$} + 2147 V~%$"$$$% + 2151 $$$$ + 2156 $~'$t$$$& + 2160 &%)$$$tKWP + 216b wPEGOW + 2173 &$$$ + 217d %$$$$$ + 2184 $$$} + 218e V$$$$$$$$$$$$$$$$~%$"$$$% + 21a8 $$$$ + 21ad $~'$t$$$& + 21b7 &$+$$$tKWP + 21c2 wPEGOW + 21cb h%$$$ + 21d3 $%$$$$$ + 21db $$$} + 21e5 V$$$$ + 21eb $$$} + 21f5 V~%$"$$$% + 21ff $$$$ + 2204 $~'$t$$$& + 220e &$+$$$tKWP + 2219 wPEGOW + 2222 v%$$$ + 222a $%$$$$$ + 2232 $$$} + 223c V$$$$ + 2242 $$$} + 224c V~%$"$$$% + 2256 $$$$ + 225b $~'$o$$$& + 2265 &%,$$$ravflehh&$$$ + 227d %$$$$$ + 2284 $$$} + 228e V$$$$$$$$$$$$$$$$~%$"$$$% + 22a8 $$$$ + 22ad $~'$o$$$& + 22b7 &$.$$$ravflehh + 22c6 h%$$$ + 22ce $%$$$$$ + 22d6 $$$} + 22e0 V$$$$ + 22e6 $$$} + 22f0 V~%$"$$$% + 22fa $$$$ + 22ff $~'$o$$$& + 2309 &$.$$$ravflehh + 2318 v%$$$ + 2320 $%$$$$$ + 2328 $$$} + 2332 V$$$$ + 2338 $$$} + 2342 V~%$"$$$% + 234c $$$$ + 2351 $~'$`$$$& + 235b &%%$$$ + 2362 &$$$ + 236c %$$$$$ + 2373 $$$} + 237d V$$$$$$$$$$$$$$$$~%$"$$$% + 2397 $$$$ + 239c $~'$`$$$& + 23a6 &$'$$$ + 23ae h%$$$ + 23b6 $%$$$$$ + 23be $$$} + 23c8 V$$$$ + 23ce $$$} + 23d8 V~%$"$$$% + 23e2 $$$$ + 23e7 $~'$`$$$& + 23f1 &$'$$$ + 23f9 v%$$$ + 2401 $%$$$$$ + 2409 $$$} + 2413 V$$$$ + 2419 $$$} + 2423 V~%$"$$$% + 242d $$$$ + 2432 $~'$`$$$& + 243c &%%$$$ + 2443 &$$$ + 244d %$$$$$ + 2454 $$$} + 245e V$$$$$$$$$$$$$$$$~%$"$$$% + 2478 $$$$ + 247d $~'$`$$$& + 2487 &$'$$$ + 248f h%$$$ + 2497 $%$$$$$ + 249f $$$} + 24a9 V$$$$ + 24af $$$} + 24b9 V~%$"$$$% + 24c3 $$$$ + 24c8 $~'$`$$$& + 24d2 &$'$$$ + 24da v%$$$ + 24e2 $%$$$$$ + 24ea $$$} + 24f4 V$$$$ + 24fa $$$} + 2504 V~%$"$$$% + 250e $$$$ + 2513 $~'$t$$$& + 251d &%)$$$eQPKIEPA@rAVF&$$$ + 253a %$$$$$ + 2541 $$$} + 254b V$$$$$$$$$$$$$$$$~%$"$$$% + 2565 $$$$ + 256a $~'$t$$$& + 2574 &$+$$$eQPKIEPA@rAVF + 2588 h%$$$ + 258e $d$%$$$$$ + 2598 $$$} + 25a2 V$$$$ + 25a8 $$$} + 25b2 V~%$"$$$% + 25bc $$$$ + 25c1 $~'$t$$$& + 25cb &$+$$$eQPKIEPA@rAVF + 25df v%$$$ + 25e5 $d$%$$$$$ + 25ef $$$} + 25f9 V$$$$ + 25ff $$$} + 2609 V~%$"$$$% + 2613 $$$$ + 2618 $~'$X%$$& + 2622 &%,$$$hmja + 2630 &$$$ + 263a %%$$$$ + 264c $$$$$$$$$$$$$$$$~%$ + 2660 %$$% + 2665 !$$$~"$ + 266d $$$$ + 2673 $$&o + 2679 P$$$$ + 267f $$$VUe + 2687 5A),$$$hmja + 2696 %%$$$$$%%$%$$$$$~"$ + 26aa $$$$ + 26b0 $$O + 26b7 $$$$ + 26bc $$$VUe + 26c4 5A),$$$hmja + 26d3 %%$$$$$%%$%$$$$$~"$ + 26e7 $$$$ + 26f3 P$$$$ + 26f9 $$$VUe + 2701 5A),$$$hmja + 2710 %%$$$$$%%%%$$$$$~"$ + 2724 $$$$ + 2730 P$$$$ + 2736 $$$VUe + 273e 5A),$$$hmja + 274d %%$$$$$%%$%$$$$$~"$ + 2761 $$$$ + 276d P$$$$ + 277e ,$$$hmja + 278a %%$$$$$%%%%$$$$$ + 279b $~'$c$$$& + 27a5 &$"$$$hmja + 27b1 %$$$ + 27b6 $g$%$$$$$ + 27cb $$$$ + 27db ~%$"$$$% + 27e4 $$$$ + 27e9 $~'$c$$$& + 27f3 &$"$$$hmja + 27ff %$$$ + 2804 $g$%$$$$$ + 2819 $$$$ + 2829 ~%$"$$$% + 2832 $$$$ + 2837 $~'$ + 283c %$$& + 2841 &%/$$$rmvpqeh + 2852 &$$$ $ + 285c %%$$$$ + 286e $$$$$$$$$$$$$$$$~%$b%$$% + 2887 !$$$~"$ + 288f $$$$ + 2895 $$&o + 289b P$$$$ + 28a1 $$$VUe + 28aa A)/$$$rmvpqeh + 28bb %%$$$$$%%$%$$$$$~"$ + 28cf $$$$ + 28d5 $$O + 28dc $$$$ + 28e1 $$$VUe + 28ea A)/$$$rmvpqeh + 28fb %%$$$$$%%$%$$$$$~"$ + 290f $$$$ + 291b P$$$$ + 2921 $$$VUe + 292a A)/$$$rmvpqeh + 293b %%$$$$$%%%%$$$$$~"$ + 294f $$$$ + 295b P$$$$ + 2961 $$$VUe + 296a A)/$$$rmvpqeh + 297b %%$$$$$%%$%$$$$$~"$ + 298f $$$$ + 299b P$$$$ + 29ac /$$$rmvpqeh + 29bb %%$$$$$%%%%$$$$$ + 29cc $~'$n$$$& + 29d6 &$-$$$rmvpqeh + 29e5 %$$$ $b$%$$$$$ + 29ff $$$$ + 2a0f ~%$"$$$% + 2a18 $$$$ + 2a1d $~'$n$$$& + 2a27 &$-$$$rmvpqeh + 2a36 %$$$ + 2a3b $b$%$$$$$ + 2a50 $$$$ + 2a60 ~%$"$$$% + 2a69 $$$$ + 2a6e $~'$ + 2a73 %$$& + 2a78 &%/$$$rmvpqeh + 2a89 &$$$ + 2a93 %%$$$$ + 2aa5 $$$$$$$$$$$$$$$$~%$b%$$% + 2abe !$$$~"$ + 2ac6 $$$$ + 2acc $$&o + 2ad2 P$$$$ + 2ad8 $$$VUe + 2ae1 A)/$$$rmvpqeh + 2af2 %%$$$$$%%$%$$$$$~"$ + 2b06 $$$$ + 2b0c $$O + 2b13 $$$$ + 2b18 $$$VUe + 2b21 A)/$$$rmvpqeh + 2b32 %%$$$$$%%$%$$$$$~"$ + 2b46 $$$$ + 2b52 P$$$$ + 2b58 $$$VUe + 2b61 A)/$$$rmvpqeh + 2b72 %%$$$$$%%%%$$$$$~"$ + 2b86 $$$$ + 2b92 P$$$$ + 2b98 $$$VUe + 2ba1 A)/$$$rmvpqeh + 2bb2 %%$$$$$%%$%$$$$$~"$ + 2bc6 $$$$ + 2bd2 P$$$$ + 2be3 /$$$rmvpqeh + 2bf2 %%$$$$$%%%%$$$$$ + 2c03 $~'$n$$$& + 2c0d &$-$$$rmvpqeh + 2c1c %$$$ + 2c21 $m$%$$$$$ + 2c36 $$$$ + 2c46 ~%$"$$$% + 2c4f $$$$ + 2c54 $~'$n$$$& + 2c5e &$-$$$rmvpqeh + 2c6d %$$$ + 2c72 $m$%$$$$$ + 2c87 $$$$ + 2c97 ~%$"$$$% + 2ca0 $$$$ + 2ca5 $~'$T%$$& + 2caf &%"$$$lt + 2cba v&$$$ + 2cc5 %%$$$$ + 2cd7 $$$$$$$$$$$$$$$$~%$ %$$% + 2cf0 !$$$~"$ + 2cf8 $$$$ + 2cfe $$&o + 2d04 P$$$$ + 2d0a $$$VUe + 2d11 !tA)"$$$lt + 2d1e v%%$$$$$%%$%$$$$$~"$ + 2d33 $$$$ + 2d39 $$O + 2d40 $$$$ + 2d45 $$$VUe + 2d4c !tA)"$$$lt + 2d59 v%%$$$$$%%$%$$$$$~"$ + 2d6e $$$$ + 2d7a P$$$$ + 2d80 $$$VUe + 2d87 !tA)"$$$lt + 2d94 v%%$$$$$%%%%$$$$$~"$ + 2da9 $$$$ + 2db5 P$$$$ + 2dbb $$$VUe + 2dc2 !tA)"$$$lt + 2dcf v%%$$$$$%%$%$$$$$~"$ + 2de4 $$$$ + 2df0 P$$$$ + 2e01 "$$$lt + 2e0a v%%$$$$$%%%%$$$$$ + 2e1c $~'$m$$$& + 2e26 &$,$$$lt + 2e33 h%$$$ + 2e39 $h$%$$$$$ + 2e4e $$$$ + 2e5e ~%$"$$$% + 2e67 $$$$ + 2e6c $~'$m$$$& + 2e76 &$,$$$lt + 2e83 v%$$$ + 2e89 $h$%$$$$$ + 2e9e $$$$ + 2eae ~%$"$$$% + 2eb7 $$$$ + 2ebc $~'$m$$$& + 2ec6 &%"$$$b| + 2ecf fQW&$$$ + 2edc %$$$$$ + 2eeb ?X*$$$$$$$$$$$$$$$$~%$"$$$% + 2f07 $$$$ + 2f0c $~'$j$$$& + 2f16 &%/$$$rrAVF + 2f27 &$$$ + 2f31 %$$$$$ + 2f41 X*$$$$$$$$$$$$$$$$~%$"$$$% + 2f5c $$$$ + 2f61 $~'$m$$$& + 2f6b &$,$$$vARAVF + 2f79 %$$$ + 2f7e $t$%$$$$$ + 2f92 2$$$$ + 2fa1 X*~%$"$$$% + 2fac $$$$ + 2fb1 $~'$j$$$& + 2fbb &%/$$$rrAVF + 2fcc &$$$ + 2fd6 %$$$$$ + 2fe6 X*$$$$$$$$$$$$$$$$~%$"$$$% + 3001 6666 + 3006 6l56|6664 + 3010 46?666w[T_ + 301b `SDT7666 + 3024 6d6766666 + 3038 6666 + 3047 J8l7606667 + 3052 6666 + 3057 6l56 + 305c 6664 + 3061 470666u^YDCE4666 + 3077 766666 + 3085 =pJ86666666666666666l7606667 + 30a2 6666 + 30a7 6l56~6664 + 30b1 461666rYCTZSD7666 + 30c3 6b6766666 + 30d7 6666 + 30e4 =pJ8l7606667 + 30f1 6666 + 30f6 6l56q6664 + 3100 460666pZWXQS7666 + 3111 6b6766666 + 3125 6666 + 3132 =pJ8l7606667 + 313f 6666 + 3144 6l56q6664 + 314e 472666r_EB4666 + 3162 766666 + 3170 =|J86666666666666666l7606667 + 318d 6666 + 3192 6l56 + 3197 5664 + 319c 475666 + 31a5 4666 + 31af 776666 + 31b6 666_ + 31c1 6666666666666666l76 + 31d5 5667 + 31da 9666l06 + 31e2 6666 + 31e8 2664} + 31ee B6666 + 31f4 666p"76 + 31fc qHG1666yCB + 320a 7766667777766666l06 + 321e 6666 + 3224 266] + 322b 6666 + 3234 _26f + 323a 71666yCB + 3246 7766667777766666l06 + 325a 6666 + 3266 B6666 + 326c 666;4 + 3277 1666{yx + 3281 d7766667777766666l06p6666 + 32a2 B6666 + 32a8 666p8 + 32b3 .666pDYXB + 32bd zSPB + 32c4 pDYXB + 32ca d_Q^B7766667777766666l06 + 32e3 6666 + 32ec R.666666 + 3300 2666 + 3308 7766666777766666l06 + 331c 6666 + 3328 B6666 + 332e 666d + 3339 1666{yx + 3343 d7766667777766666l06w6666 + 3364 B6666 + 3374 R%666tC_ZB + 3382 yCBFCB + 338c 7766667777766666l06 + 33a0 6666 + 33ad 6666 + 33b2 666;4 + 33bd 1666{yx + 33c7 d7766667777766666l06 + 33dc 6666 + 33e8 B6666 + 33ee 666;4 + 33f9 1666{yx + 3403 d7766667777766666l06 + 3418 6666 + 3425 6666 + 342a 666;4 + 3435 1666{yx + 343f d7766667777766666l06 + 3454 6666 + 3461 6666 + 3466 666;4 + 3471 1666{yx + 347b d7766667777766666l06p6666 + 349d 6666 + 34a2 666p8 + 34ad .666pDYXB + 34b7 zSPB + 34be pDYXB + 34c4 d_Q^B7766667777766666l06w6666 + 34ea 6666 + 34fa %666tC_ZB + 3507 yCBFCB + 3511 7766667777766666l06 + 3525 6666 + 352d 5[D666666 + 3537 666` + 3541 q3666w + 354b 7766666777766666l06 + 355f 6666 + 356a 666666 + 3571 666r5 + 357c 3666w + 3585 7766666777766666 + 3596 6l56t6664 + 35a0 467666 + 35a7 7666 + 35ac 6n6766666 + 35b6 666_ + 35c1 6666 + 35c6 666_ + 35d1 l7606667 + 35da 6666 + 35df 6l56t6664 + 35e9 467666 + 35f0 7666 + 35f5 6n6766666 + 35ff 666_ + 360a 6666 + 360f 666_ + 361a l7606667 + 3623 6666 + 3628 6l56y6664 + 3632 47:666`rSZWO + 3644 4666 6v6 + 364e 766666 + 365e J86666666666666666l7606667 + 3679 6666 + 367e 6l56}6664 + 3688 46<666`rSZWO + 3698 7666 6m6766666 + 36b1 6666 + 36c0 J8l7606667 + 36cb 6666 + 36d0 6l56z6664 + 36da 46=666`rSZWO + 36eb 7666v6m6766666 + 3704 6666 + 3713 J8l7606667 + 371e 6666 + 3723 6l46V"66 + 372c &z666l16 + 3739 &670666 + 3746 46667646 + 3750 76666 + 3756 666`"76g{HG666 + 3766 60666 + 3771 76l16 + 377b &662666 + 3786 7666766676666 + 3794 666`"76b{HG666 + 37a4 62666 + 37ad 66l16 + 37b7 &662666 + 37c2 7666466676666 + 37d0 666`"76c{HG666 + 37e0 62666 + 37e9 66l16 + 37f3 &771666yCB + 3801 46667646 + 380b 76666 + 3811 666p"76 + 3819 qHG666 + 3821 61666yCB + 382d 76l16 + 3837 &472666dYY[46665626 + 384c 76666 + 385b L}666 + 3862 62666dYY[76l16 + 3875 &460666dYY[ + 3881 z7666561676666 + 3899 L}666 + 38a0 60666dYY[ + 38aa z66l16 + 38b5 &460666dYY[ + 38c1 d7666261676666 + 38d9 L}666 + 38e0 60666dYY[ + 38ea d66l16u666 + 38f5 &47<666fZWBS + 3902 `SDT46663606 + 3910 76666 + 391f L}666 + 3926 6<666fZWBS + 3931 `SDT76l16s666 + 393f &46:666fZWBS + 394c `SDT + 3951 z766636<676666 + 3969 L}666 + 3970 6:666fZWBS + 397b `SDT + 3980 z66l16s666 + 398b &46:666fZWBS + 3998 `SDT + 399d d766606<676666 + 39b5 L}666 + 39bc 6:666fZWBS + 39c7 `SDT + 39cc d66l16 + 39d7 &472666uy{f466616>6 + 39ec 76666 + 39fb L}666 + 3a02 62666uy{f76l16 + 3a15 &460666uy{f + 3a21 z766616;676666 + 3a39 L}666 + 3a40 60666uy{f + 3a4a z66l16 + 3a55 &460666uy{f + 3a61 d7666>6;676666 + 3a77 ~ L}666 + 3a80 60666uy{f + 3a8a d66l16u666 + 3a95 &47<666fYEBeBWU]E4666?6<6 + 3ab0 76666 + 3abd qwL}666 + 3ac6 6<666fYEBeBWU]E76l16s666 + 3adf &46:666fYEBeBWU]E + 3af1 z7666?6&676666 + 3b08 wL}666 + 3b10 6:666fYEBeBWU]E + 3b20 z66l16s666 + 3b2b &46:666fYEBeBWU]E + 3b3d d7666<6&676666 + 3b54 tL}666 + 3b5c 6:666fYEBeBWU]E + 3b6c d66l16 + 3b77 &473666rWrC[4666=6:6 + 3b8d 76666 + 3b9a (rL}666 + 3ba3 63666rWrC[76l16 + 3bb7 &461666rWrC[ + 3bc4 z7666=6%676666 + 3bdb rL}666 + 3be3 61666rWrC[ + 3bee z66l16 + 3bf9 &461666rWrC[ + 3c06 d7666:6%676666 + 3c1c !sL}666 + 3c25 61666rWrC[ + 3c30 d66l16s666 + 3c3b &47=666u^YDCErYCTS4666;686 + 3c57 76666 + 3c65 qL}666 + 3c6d 6=666u^YDCErYCTS76l16q666 + 3c87 &46;666u^YDCErYCTS + 3c9a z7666;6 676666 + 3cb1 qL}666 + 3cb9 6;666u^YDCErYCTS + 3cca z66l16q666 + 3cd5 &46;666u^YDCErYCTS + 3ce8 d766686 676666 + 3cfe 7~L}666 + 3d07 6;666u^YDCErYCTS + 3d18 d66l16w666 + 3d23 &47?666tCE + 3d33 466696&6 + 3d3d 76666 + 3d4a |L}666 + 3d53 6?666tCE + 3d61 76l16 + 3d6b &460666tCE + 3d78 766696/676666 + 3d8e |L}666 + 3d96 60666tCE + 3da1 66l16 + 3dab &460666tCE + 3db8 7666&6/676666 + 3dce }L}666 + 3dd6 60666tCE + 3de1 66l16u666 + 3deb &47<666~WD + 3df6 eBWU]E4666'6$6 + 3e06 76666 + 3e13 O{L}666 + 3e1c 6<666~WD + 3e25 eBWU]E76l16s666 + 3e35 &46:666~WD + 3e40 eBWU]E + 3e47 z7666'6*676666 + 3e5e {L}666 + 3e66 6:666~WD + 3e6f eBWU]E + 3e76 z66l16s666 + 3e81 &46:666~WD + 3e8c eBWU]E + 3e93 d7666$6*676666 + 3ea9 VxL}666 + 3eb2 6:666~WD + 3ebb eBWU]E + 3ec2 d66l16w666 + 3ecd &47?666tCE + 3edd 4666%6"6 + 3ee7 76666 + 3ef5 fL}666 + 3efd 6?666tCE + 3f0b 76l16 + 3f15 &460666tCE + 3f22 7666%6)676666 + 3f38 gL}666 + 3f40 60666tCE + 3f4b 66l16 + 3f55 &460666tCE + 3f62 7666"6)676666 + 3f78 gL}666 + 3f80 60666tCE + 3f8b 66l16 + 3f95 &475666`yn4666#6 6 + 3fa9 76666 + 3fb6 1bL}666 + 3fbf 65666`yn76l16 + 3fd1 &463666`yn + 3fdc z7666#6 + 3fe4 676666 + 3ff2 DbL}666 + 3ffb 63666 + 400b HHHiXJHMHHH + 401b IHHH^HjHIHHHHbHHH + 4039 HMHHH + 4046 OH HHHiXJIAHHH + 4055 =;hzyezzJHHH_HPH + 4067 IHHHHbHHH + 407d HAHHH + 4083 =;hzyezzIH + 408e OHqHHHiXJHNHHH + 409d =;hzyIHHH_HmHIHHHHbHHH + 40c0 HNHHH + 40c6 =;hzyHH + 40ce OHqHHHiXJHNHHH + 40dd =;hzzIHHHPHmHIHHHHbHHH + 4100 HNHHH + 4106 =;hzzHH + 410e OH HHHiXJIAHHH + 4121 -$)1JHHHQHRH + 412f IHHHHbHHH + 4145 HAHHH + 414f -$)1IH + 4159 HHHiXJHCHHH + 4169 -$)1f + 416f IHHHQH`HIHHHHbHHH + 418d HCHHH + 4197 -$)1f + 41a3 HHHiXJHCHHH + 41b3 -$)1f + 41b9 IHHHRH`HIHHHHbHHH + 41d7 HCHHH + 41e1 -$)1f + 41ea OHyHHHiXJIIHHHyJHHHUHVH + 4203 IHHHHbHHH + 4213 :HHH + 4219 HIHHHyIH + 4222 OH{HHHiXJHKHHHyf + 4233 IHHHUHfHIHHHHbHHH + 424b :HHH + 4251 HKHHHyf + 425c OH{HHHiXJHKHHHyf + 426d IHHHVHfHIHHHHbHHH + 4285 :HHH + 428b HKHHHyf + 4296 OHqHHHiXJIMHHH + 42a5 -$)1JHHHWHhH + 42b3 IHHHHbHHH + 42c3 :HHH + 42c9 HMHHH + 42cf -$)1IH + 42d6 OHsHHHiXJHOHHH + 42e5 -$)1f + 42eb IHHHWHyHIHHHHbHHH + 4303 :HHH + 4309 HOHHH + 430f -$)1f + 4318 OHsHHHiXJHOHHH + 4327 -$)1f + 432d IHHHhHyHIHHHHbHHH + 4345 :HHH + 434b HOHHH + 4351 -$)1f + 435d HHHiXJIEHHH + 4369 ';-:*hyIHHH}H + 481b HIHHHHbHHH + 482c ^HHH + 4832 H@HHH + 4838 ->-:*hyHH + 4845 HHHiXJICHHH + 4852 -:*h + 4857 =;h{JHHH + 4865 IHHHHbHHH + 4873 u4FHHH + 487b HCHHH + 4882 -:*h + 4887 =;h{IH + 488e OHwHHHiXJHAHHH %*!h + 48a2 -:*IHHH + 48ac HIHHHHbHHH + 48bd ^HHH + 48c3 HAHHH %*!h + 48ce -:*HH + 48d4 OHsHHHiXJINHHH + 48e3 ':=;JHHHqHrH + 48f2 IHHHHbHHH + 4901 4FHHH + 4908 HNHHH + 490e ':=;IH + 4916 OHsHHHiXJHOHHH + 4925 '=*$-:IHHHqH + 4932 HIHHHHbHHH + 4943 ^HHH + 4949 HOHHH + 494f '=*$-:HH + 4958 OHqHHHiXJHNHHH + 4967 $)&/-IHHHrH + 4973 HIHHHHbHHH + 4984 ^HHH + 498a HNHHH + 4990 $)&/-HH + 499b HHHiXJILHHH + 49a7 !;ZPZfZ%ZPZ[Z[[ZZ + 51c4 t[ZZZZZZ + 51d2 ^ZZyz[ + 51d9 DZZZZZZZZ^ZZ[ZZZZZZZZZZZ + 51f2 ZZZZZZZ + 51fa [ZZZZZZZZ[_ZZ[ZZZZ[Z + 520f TZZZZZKqZZZZZZZZZZZZZZZZZZZZZZZRZZZZZZZZZZZZZZZZ[[[ZZZZ + 5247 [ZQZZZn~^ZZZZZZfZZ + 525f ZZZ_zZZZZ[ZZZ + 526d YZ*ZZZ\z + 5277 SZZZ + 527c (363;4zkZ + 5286 XZ ZZZ + 528d zZSZZZ + 5294 (363;4zkZZZZ + 52a1 [ZbZZZ + 52a8 zZZSZZZ + 52b0 (363;4zk[ + 52ba ^ZEZZZ + 52c1 z[YZZZZZZZZZZZ + 52de !ZZZZ + 52e4 [ZPZZZ_zZZZZZZZZ + 52f8 YZZ_zZZZZRZZZ + 5306 YZ1ZZZ\z + 5310 NZZZ + 5315 "*(?))zzkhbvz + 5323 5(.zk + 5331 zZNZZZ + 5338 "*(?))zzkhbvz + 5346 5(.zk[ZZZ + 5350 [ZGZZZ + 5357 zZZNZZZ + 535f "*(?))zzkhbvz + 536d 5(.zkZZZZZ + 5378 YZ1ZZZ\z + 5382 NZZZ + 5387 "*(?))zzkhbvz + 5395 5(.zh + 53a3 zZNZZZ + 53aa "*(?))zzkhbvz + 53b8 5(.zh[ZZZ + 53c2 [ZGZZZ + 53c9 zZZNZZZ + 53d1 "*(?))zzkhbvz + 53df 5(.zhZZZZZ + 53ea YZ1ZZZ\z + 53f4 NZZZ + 53f9 "*(?))zzkhbvz + 5407 5(.zi + 5415 zZNZZZ + 541c "*(?))zzkhbvz + 542a 5(.zi[ZZZ + 5434 [ZGZZZ + 543b zZZNZZZ + 5443 "*(?))zzkhbvz + 5451 5(.ziZZZZZ + 545c YZ1ZZZ\z + 5466 NZZZ + 546b "*(?))zzkhbvz + 5479 5(.zn + 5487 zZNZZZ + 548e "*(?))zzkhbvz + 549c 5(.zn[ZZZ + 54a6 [ZGZZZ + 54ad zZZNZZZ + 54b5 "*(?))zzkhbvz + 54c3 5(.znZZZZZ + 54ce YZ1ZZZ\z + 54d8 NZZZ + 54dd "*(?))zzkhbvz + 54eb 5(.zo + 54f9 zZNZZZ + 5500 "*(?))zzkhbvz + 550e 5(.zo[ZZZ + 5518 [ZGZZZ + 551f zZZNZZZ + 5527 "*(?))zzkhbvz + 5535 5(.zoZZZZZ + 5540 YZ1ZZZ\z + 554a NZZZ + 554f "*(?))zzkhbvz + 555d 5(.zl + 556b zZNZZZ + 5572 "*(?))zzkhbvz + 5580 5(.zl[ZZZ + 558a [ZGZZZ + 5591 zZZNZZZ + 5599 "*(?))zzkhbvz + 55a7 5(.zlZZZZZ + 55b2 YZ1ZZZ\z + 55bc NZZZ + 55c1 "*(?))zzkhbvz + 55cf 5(.zm + 55dd zZNZZZ + 55e4 "*(?))zzkhbvz + 55f2 5(.zm[ZZZ + 55fc [ZGZZZ + 5603 zZZNZZZ + 560b "*(?))zzkhbvz + 5619 5(.zmZZZZZ + 5624 YZ1ZZZ\z + 562e NZZZ + 5633 "*(?))zzkhbvz + 5641 5(.zb + 564f zZNZZZ + 5656 "*(?))zzkhbvz + 5664 5(.zb[ZZZ + 566e [ZGZZZ + 5675 zZZNZZZ + 567d "*(?))zzkhbvz + 568b 5(.zbZZZZZZ[ + 569b ZZZF} + 56a4 ZZZC|WZZZ + 56ae 25(>z #7856)ZZ[ZZZZpZZZ" + 56cc Z_wK + 56dc uZZZZZZZZ[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ + 570b [ZxZZZ[ + 5713 ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ_wK + 5744 [Z\ZZZm~ZZZZ + 5751 [Z\ZZZm~ZZZZ + 575e ^ZKZZZ^|ZZZZZZZZZZ[ZZZZ + 5776 [Z\ZZZ~|ZZZZ + 5786 ZZZqz[ZZZ + 5790 _ZZZZ[ZZZYZZZXZZZZZZZ[[Z[RZZZZZZZ + 592d ZZZZ[ZZZ + 5940 YXJZ + 5946 ZZ_Z[ZZZZZZZZZZZZZZZZZZZZ[[ZZZZZZZZZZZSZZZ + 5971 4.3.6?>h[Z[[ZZZZZ[ + 5984 XZQZZZ!zZYZ + 5990 YZZ_Z + 5999 YZZLz + 599f [ZNZZZKzZZZZwZZZ + 59b0 _ZZ{YZZ[[ZZZZZZZZ[ + 59c7 ^ZZZ + 59cc ZZZZZZZ[[[ZZZZZZZZZ + 59e0 [ZZZZZZ + 59eb jZZJ + 5a0d ZZZZZZZZ[ZZZZ[[Z[[[ZZZ>ZZZZZZ + 5a2f ZZZz kO + 5a37 [Z[ZZZZZ[[[ZZZZZZZZZ[ZZZ[[[[Z[ZZJ + 5a5e ZZ[[ZZqZqZZZ[[ + 5a76 XZ{ZZZ + 5a81 [ZNZZZKzZZZZZZZZZZZZZZZZZZZZ + 5aa1 ZZZ + 5aac ^ZZZ + 5ab1 ZZZ[ZZZ[[[[Z[Z>ZZZZZZ + 5acb ZZZz kO + 5ad3 WZZZZ[ZZZ[[ZZZZZ[Z>ZZZ[ZZ[[[ + 5af0 [Z}ZZZ + 5af8 QZZZhZZRZ[iZ[[Z[XZ[YZ[^Z[_Z[]ZZSZ[\Z[[vZZZZ + 5b24 ZZZZ[[[[ + 5b30 ZZZ[ + 5b3b _ZZZZZZZZ + 5b46 _ZWZZZzzzzj&zj&zhnjPZZZzzj`jjtkjjTZZZjj`jj`jj`jktjjQZZZzzzzjqjktjjQZZZzzzzzzzzkjj_Z[ZZZz[ZZZz[ZZZz[ZZZz[ZZZzIZ~ZMZqZZ + 5bbc jZZYZZZZZZ + 5bc7 [Zv[ZZ + 5bd0 XZE[ZZ + 5bd8 ZZZZZZZZZZZZZZ + 5be8 ZZQZZZZ[XPY^\RSQ_ + 5bfa \ZqZZZ + 5c01 z[ZZZZZZZZ^ZZZXZZZYZZZZZZZZZZZZZXZZZ[ZZZ + 5c2a ZZZZZ + 5c33 ZZZZZZ>ZZZ + 5dab [ZZZ[Z[ZZZ + 5db6 XZEZZZAz + 5dbf [ZNZZZKzrZZZhZZZ5XZZ + 5dd4 ZZZZ[ZZ + 5ddc [ZGZZZFz + 5de5 [ZNZZZKzZZZZZZZZZZZZZZZZZZ + 5e00 [ZGZZZGz + 5e09 [ZNZZZKz + 5e1e ZZZZ[ + 5e24 XZDZZZDz + 5e2d [ZNZZZKz + 5e3a [ZZdXZZ + 5e42 ZZZZ[Z + 5e49 _ZwZZZEz + 5e52 [ZNZZZKz + 5e67 ZZZZ[[ZZ[[[[[[[[[[Z[[ + 5e7d XZ{ZZZ + 5e86 [ZNZZZKzYZZZsZZZKYZZ + 5e9b ZZZZ[[hZZ + 5ea5 [ZGZZZ + 5eae [ZNZZZKzCZZZ + 5ec3 ZZZZ[ + 5ecc ZZZ0z + 5ed2 [ZNZZZKz>ZZZ>ZZZ5[ZZN[ZZZZZZ[[Z + 5ef9 ZZZ.z + 5f02 ZZZ*zZZZ[[ZZRZZZZZZZZZZZRZZZ[X^ + 5f27 ZZZZ[[Z[[Z[ZZ[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ[[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ + 5fab [ZEZZZ + 5fb4 [ZNZZZKzv[ZZv[ZZ + 5fc9 [ZZZZZZ + 5fd1 [ZGZZZ6z + 5fda [ZNZZZKzwZZZwZZZZZZZZZZZZ[ + 5ff5 [ZGZZZ + 5ffe [Zxlll}LAlllAllllllllllllm6mlYlll + 6020 I6mlxlll}LAlllAllllllllllllmlmlmmllmmmmolllmllllilll6nlMlll + 605c I6mlxlll}Lllllllll + 6073 lllllllll6mlqlll + 6084 L6mlxlll}L + 6097 mllxmllll6mlqlll + 60a8 L6mlxlll}LllllKlllmlllmlllll6mlqlll + 60cc L6mlxlll}L + 60db lllmlllmlllll6mlolll + 60f0 Im6nl{mll + 60fa Lolllmllollllmmollllllolllilll`lllLLL] + 6124 L\\\flllLL\V\\B\\]blll\\V\\V\]V\\B\\glllLLLL]G\\B\\mlll]illl`lllLLL\ + 616c LXT\flllLL\V\]B\\\blll\\V\\V\]V\\B\\glllLLLL]G\\B\\glllLLLLLL]\\\\illl`lllLLL^ + 61be L\\\flllLL\V\YB\\\blll\\V\\V\YV\\B\\glllLLL^\G\\B\\glllLLLLLUZ\\\\olll + 6208 llll + 6218 L6ml + 6221 Lnllmmlldllllllllllldlllmnh,kfi- + 6242 llllmmlmmlmllmlllllllllllllllllllllllllllllllllllllllllllllllllllllmmllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll6ml + 62cd L6ml + 62d6 Lnllmmlldllllllllllldlllmnh,kfi- + 62f7 llllmmlmmlmllmlllllllllllllllllllllllllllllllllllllllllllllllllllllmmllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll6mljlllALllll6mljlllBLllll6mljlllCHllll6ml + 63a5 lllvK6kl + 63ae llluJklll! + 63be llmllllFlll + 63e0 ullllllllmllllllllllllllllllllllllllllllllllll6mlNlllm/llllllllllllllllllllllllllllllll= + 6446 u6hlflll\Lllllllll6hlflll\Lllllllll6mlelllIHl6mlxlll}L{lll!lll + 64ac nllllllllll6jlGlll:Llllllllllmlllhlllolllllllllllllnlllmlll + 64e8 l6nl + 64f1 Lmllllmllllmllllmlllilll`lllLLL\ + 6515 L\\\flllLL\V\]B\\\blll\\V\\V\]V\\B\\glllLLLL]G\\B\\glllLLLLLL]\\\\mlll + 6567 ZSllll + 656e mllUmllmlmm6ml~lll + 6581 IhlllGlmBlm@lm\lm6ml + 659a I6nl + 659f oll=I + 65a6 flllD + 65b3 Ellllmmmmlnlll6ml + 65c9 I6nlMlll>Iol6mlxlll}LllllAlll + 65e7 illMolllmll6fl + 65f6 lll?Im + 65fd lll0hlll + 6606 lllmlllmmmmlml + 6615 llllll + 661e |,lllL + 6625 ]y,allllmlllmmlllllml + 663b lllmllmmm6mlKlll + 664c Iglll^lldlm_lmmlmnlmolmhlmilmkllelmjlmm@llll + 6679 llllmmmm6jl + 6685 lllmIm + 6690 illllllll + 669a ,ilalllLLLL\ + 66aa L^X\flllLL\V\\B]\\blll\\V\\V\\V\]B\\glllLLLL\G\]B\\glllLLLLLLLL]\\ilmlllLmlllLmlllLmlllLmlllL + 6708 lHl{lGll + 6711 \llollllll6ml@mll + 6723 I6nlsmll + 672c Illllllllllllll + 673c ,llgllllmnfohjdegi6jlGlll:LmllllllllhlllnlllolllllllllllllnlllmlllInl6mlxlll}LllllAlll + 686b illNollllllllll6fl6lll?Immlll + 688a ]lmolllmllllllmlmmllll\lllllll + 68ac mllllllll + 68b9 mmlmlm6mljlll + 68c7 Illlll@llll + 68d3 llllmmmm6dl]lll8Im + 68e6 lll"nlllmmllmmlmm + 68f8 lllmlliflllllllllllllml9llln6ol6lll + 691c Lilllllllll + 6928 ,lllllD + 6930 ,lllll + 6938 ,llllllP,llllll + 6948 Sillllllll{m-lllll{ + 695c ,lllll + 6964 ,lllll + 6973 i,6nlrnll|Iklll| + 6984 mlllll| + 698c mlllll| + 6994 mlllll| + 699c mlllll| + 69a4 mlllll| + 69ac mlllllmlllllllklll6nlQlll + 69c6 Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6a0a Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6a4e Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6a92 Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6ad6 Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6b1a Immllllllmllllllllllllllllllllllllllllllllllllllllllllllllll6nlQlll + 6b5e Illllmllllllllllllllllllllllllllllllllllllllllllllllllllllll6nljlll%|llll6nl{lll + 6baf Lmllllmllllmllllmllllm6mljlllnOllll6ml + 6bd6 hllfO\l6ml|lllgOdlll/ + 6bf0 L]ll6ml|lllgOdlll/ + 6c07 L^ll6ml|lllgOdlll/ + 6c1e L_ll6ml|lllgOdlll/ + 6c35 LXll6ml|lllgOdlll/ + 6c4c LYll6ml|lllgOdlll/ + 6c63 LZll6ml|lllgOdlll/ + 6c7a L[ll6ml|lllgOdlll/ + 6c91 LTll6ml|lllgOdlll/ + 6ca8 LUll6ml}lllgOelll/ + 6cbf L]\ll6ml}lllgOelll/ + 6cd7 L]]ll6ml}lllgOelll/ + 6cef L]^ll6ml}lllgOelll/ + 6d07 L]_ll6ml}lllgOelll/ + 6d1f L]Xll6ml}lllgOelll/ + 6d37 L]Yll6ml}lllgOelll/ + 6d4f L]Zll6ml}lllgOelll/ + 6d67 L][ll6ml}lllgOelll/ + 6d7f L]Tll6ml}lllgOelll/ + 6d97 L]Ull6ml}lllgOelll/ + 6daf L^\ll6ml}lllgOelll/ + 6dc7 L^]ll6ml}lllgOelll/ + 6ddf L^^ll6ml}lllgOelll/ + 6df7 L^_ll6ml}lllgOelll/ + 6e0f L^Xll6ml}lllgOelll/ + 6e27 L^Yll6ml}lllgOelll/ + 6e3f L^Zll6ml}lllgOelll/ + 6e57 L^[ll6ml}lllgOelll/ + 6e6f L^Tll6ml}lllgOelll/ + 6e87 L^Ull6ml}lllgOelll/ + 6e9f L_\ll6ml}lllgOelll/ + 6eb7 L_]ll6ml}lllgOelll/ + 6ecf L_^ll6ml}lllgOelll/ + 6ee7 L__ll6ml}lllgOelll/ + 6eff L_Xll6ml}lllgOelll/ + 6f17 L_Yll6ml}lllgOelll/ + 6f2f L_Zll6ml}lllgOelll/ + 6f47 L_[ll6ml}lllgOelll/ + 6f5f L_Tll6ml}lllgOelll/ + 6f77 L_Ull6ml}lllgOelll/ + 6f8f LX\ll6ml}lllgOelll/ + 6fa7 LX]ll6ml}lllgOelll/ + 6fbf LX^ll6ml}lllgOelll/ + 6fd7 LX_ll6ml}lllgOelll/ + 6fef LXXll6ml}lllgOell~= + 7007 ^JK~~$ + 700e ~o~~~u]w~~~= + 701f ^JH~~$ + 7026 ~o~~~u]w~~~= + 7037 ^JI~~$ + 703e ~o~~~u]w~~~= + 704f ^JF~~$ + 7056 ~x~~~{]~~~~$ + 7063 ~?~~~ + 706e ~H~~~ + 7074 ^~z~z~ + 707b ~~~~~|~ + 7087 ~}~~~~~|~~~}~~~~~~~~~~~~~~~~~~~ + 70a8 ~$v~V~~~ + 70b4 ~j~~~o^ + 70c0 |~~[|~~ + 70c8 ~~~~~z~{~ + 70d6 v~$}~ + 70dc ~~~{[$ + 70e3 ~j~~~o^0|~~ + 70ef ~~~G + 70f8 ~~~~ + 70ff ~~$|~ + 7105 ~~~|[ + 710e $|~E~~~Cn;~~~~~~~~2s?~~~~~2 + 712a >{~~~}~~~|~~~~~~~~~~~ + 7140 ~~~~~~~ + 7148 ~~~~~~~ + 7155 ~~~~~~ + 715e p~~~~~ + 7165 }~~~~~~~~ + 7174 }~~~~~~~~L + 717f {~~~~ + 7189 ~~~~~~~~~~~~~ + 719d ~~~~B~~$ + 71a6 ~c~~~T[$ + 71af ~j~~~o^ + 71bb |~~N + 71c0 ~~I~~~~~$x~ + 71d7 {~~~~~~~~ + 71e1 >{~s~~~^^^^N + 71f1 ^LJNt~~~^^NDNNPONNp~~~NNDNNDNNDNOPNNu~~~^^^^NUNOPNNu~~~^^^^^^^^ONN{~ + 7236 ~~~^ + 723b ~~~^ + 7240 ~~~^ + 7245 ~~~^ + 724a ~~~^m~Z~i~U~~ + 7258 N~~}~~~~~~$ + 7264 ~q~~~VZ$ + 726d ~x~~~*n~~~~$ + 727a ~q~~~PZ$ + 7283 ~x~~~&n~~~~$ + 7290 ~q~~~NZ$ + 7299 ~x~~~+n~~~~$ + 72a6 ~x~~~ZZ~~~~$ + 72b3 ~x~~~XZ~~~~$ + 72c0 ~c~~~y[$ + 72c9 ~j~~~o^ + 72dd ~~~~~$y~I~~~v[ + 72f1 ~~~~~~ + 7300 }y~~~y~~~: + 7316 ~~~~~ + 7320 $|~I~~~ + 7330 ~~$}~e~~~w[~~~~~~~~ + 7347 ~~~~~~~~~~~~~~~~~~ + 735b ~~~$}~t~~~y_~~~~~~~~$ + 7371 ~x~~~aY~~~~$ + 7381 ~~N[}~~~ + 738a ~~}~~~~ + 7393 }~~~~~~}~~~{~~~r~~~^^^O + 73ae ^NNNt~~~^^NDNNPNNOp~~~NNDNNDNODNNPNNu~~~^^^^OUNNPNN + 73e2 ~~~O{~~~r~~~^^^N + 73f6 ^JFNt~~~^^NDNOPNNNp~~~NNDNNDNODNNPNNu~~~^^^^OUNNPNNu~~~^^^^^^ONNNN{~~~r~~~^^^L + 7448 ^NNNt~~~^^NDNKPNNNp~~~NNDNNDNKDNNPNNu~~~^^^LNUNNPNNu~~~^^^^^GHNNNN}~~~ + 7492 ~~~~ + 749a $f~\~~~h[~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~$ + 74c5 ~:~~~hY + 74cd ~~~$ + 74d2 ~I~~~kYk~~~ + 74f0 HJp~~~?/?????????Cstx~~~< + 750c HJ$|~ + 7512 m~~|~ + 751c ~~~}~ + 7525 ~~~~~ + 7532 ~a~~~~~~~~~ + 753e ~~~Cq + 7548 ~~~~ + 7556 |~~~~~~~~ + 7560 ~~~zn + 7569 ~~~~~ + 7578 |~~~~~~~~ + 7582 ~~~xn + 758b ~~~~~ + 759a |~~~~~~~~ + 75a4 ~~~kn + 75ae ~~~~ + 75ba ~%r~~~~~~~~ + 75c6 ~~~fn + 75cf ~~~~~ + 75de r~~~~~~~~ + 75e8 ~~~\n + 75f1 ~~~~~ + 75fe ~ZI~~~~~~~~ + 760a ~~~Vn + 7613 ~~~~~ + 7623 ~~~~~~~~ + 762c ~~~>n + 7635 ~~~~~ + 7644 }~~~~~~~~}~~~>n + 7657 ~~~~~?n + 765f }~~~~~~~Z + 64d Z + 6f2 n tbdi + 8b4 Snap1 + 8bd Snap2 + 8c6 Snap3 + 8cf Snap4 + 8d8 Snap5 + 8e1 Snap6 + 8ea Snap7 + 8f3 Snap8 + 8fc Snap9 + 905 Snap10 + 90f Snap11 + 919 Snap12 + 923 Snap13 + 92d Snap14 + 937 Snap15 + 941 Snap16 + 94b Snap17 + 955 Snap18 + 95f Snap19 + 969 Snap20 + 973 Snap21 + 97d Snap22 + 987 Snap23 + 991 Snap24 + 99b Snap25 + 9a5 Snap26 + 9af Snap27 + 9b9 Snap28 + 9c3 Snap29 + 9cd Snap30 + 9d7 Snap31 + 9e1 Snap32 + 9eb Snap33 + 9f5 Snap34 + 9ff Snap35 + a09 Snap36 + a13 Snap37 + a1d Snap38 + a27 Snap39 + a31 Snap40 + a3b Snap41 + a45 Snap42 + a4f Snap43 + a59 Snap44 + a63 Snap45 + a6d Snap46 + a77 Snap47 + a81 Snap48Z + ada 0| 0| 060 + aec 0:00.001 + afb 00:00:00:00.01 + b0e 0+00.01 + b1e 1 + bab 24:00:00:00Z + c64 PolyphonicigiDPleFyloP + c85 com.avid.aax.fela.2solaZ + cb8 A 1-2 + d13 $G~q + d1b Out 1-2 + d57 Out 1-2 + d93 MON L/R + dcf Front Left / Front Right + e1c MON L/R + e58 Built-in Output 1-2 + ea0 MON L/R + edc MON L/R + f18 MON L/R + f54 MON L/R + f90 Front Left / Front Right + fdd Built-in Output 1-2 + 1001 RTgTTTTrTC + 100c W9&TTTTTT~TTT + 1021 QTTT + 1026 teyfUUTTTTTUUUUTTTTT + 103b RTgTTTTr|cc^ + 1049 TTTTTT~TTT + 105b QTTT + 1060 teyfUUTTTTTUUUUTTTTT + 107a TTTVrVTWTTT + 1086 teUTTTUTPTUTTTTT~TTT= + 10a1 oTTTT~TTT= + 10b3 UTRTTTUrTTTT + 10c5 TTTVrVTWTTT + 10d1 tfUTTTVTPTUTTTTT~TTT= + 10ec oTTTT~TTT= + 10fe UTRTTTUrTTTT + 1110 TTTVrVUPTTT + 111c ;;9VTTTWTPT + 1129 UTTTTT~TTT + 113b TTTTTTTTTTTTTTTT + 114c UTRTTTUrTTTT + 115e TTTVrVTRTTT + 116a ;;9z + 116f UTTTWTSTUTTTTT~TTT + 1189 TTTT~TTT + 119a UTRTTTUrTTTT + 11ac TTTVrVTRTTT + 11b8 ;;9z + 11bd UTTTPTSTUTTTTT~TTT + 11d7 TTTT~TTT + 11e8 UTRTTTUrTTTT + 11fa TTTVrVU^TTT + 1206 85 1t + 120c 1&6VTTTQTRT + 1219 UTTTTT~TTT + 122b TTTTTTTTTTTTTTTT + 123c UTRTTTUrTTTT + 124e TTTVrVTXTTT + 125a 85 1t + 1260 1&6z + 1265 UTTTQT^TUTTTTT~TTT + 127f TTTT~TTT + 1290 UTRTTTUrTTTT + 12a2 TTTVrVTXTTT + 12ae 85 1t + 12b4 1&6z + 12b9 UTTTRT^TUTTTTT~TTT + 12d3 TTTT~TTT + 12e4 UTRTTTUrTTTT + 12f6 TTTVrVUPTTT + 1305 VTTTST\T + 130f UTTTTT~TTT + 1321 TTTTTTTTTTTTTTTT + 1332 UTRTTTUrTTTT + 1344 TTTVrVTRTTT + 1355 UTTTSTYTUTTTTT~TTT + 136f TTTT~TTT + 1380 UTRTTTUrTTTT + 1392 TTTVrVTRTTT + 13a3 UTTT\TYTUTTTTT~TTT + 13bd TTTT~TTT + 13ce UTRTTTUrTTTT + 13e0 TTTVrVU^TTT + 13f0 57?'VTTT]T^T + 13ff UTTTTT~TTT + 1411 TTTTTTTTTTTTTTTT + 1422 UTRTTTUrTTTT + 1434 TTTVrVTXTTT + 1444 57?'z + 144b UTTT]TDTUTTTTT~TTT + 1465 TTTT~TTT + 1476 UTRTTTUrTTTT + 1488 TTTVrVTXTTT + 1498 57?'z + 149f UTTT^TDTUTTTTT~TTT + 14b9 TTTT~TTT + 14ca UTRTTTUrTTTT + 14dc TTTVrVUQTTT + 14ea !9VTTT_TXT + 14f6 UTTTTT~TTT + 1508 TTTTTTTTTTTTTTTT + 1519 UTRTTTUrTTTT + 152b TTTVrVTSTTT + 153d UTTT_TGTUTTTTT~TTT + 1557 TTTT~TTT + 1568 UTRTTTUrTTTT + 157a TTTVrVTSTTT + 158c UTTTXTGTUTTTTT~TTT + 15a6 TTTT~TTT + 15b7 UTRTTTUrTTTT + 15c9 TTTVrVU_TTT + 15d5 <;&!' + 15db ;!61VTTTYTZT + 15e9 UTTTTT~TTT + 15fb TTTTTTTTTTTTTTTT + 160c UTRTTTUrTTTT + 161e TTTVrVTYTTT + 162a <;&!' + 1630 ;!61z + 1636 UTTTYTBTUTTTTT~TTT + 1650 TTTT~TTT + 1661 UTRTTTUrTTTT + 1673 TTTVrVTYTTT + 167f <;&!' + 1685 ;!61z + 168b UTTTZTBTUTTTTT~TTT + 16a5 TTTT~TTT + 16b6 UTRTTTUrTTTT + 16c8 TTTVrVU]TTT + 16d4 !'tegye`VTTT[TDT + 16e6 UTTTTT~TTT + 16f8 TTTTTTTTTTTTTTTT + 1709 UTRTTTUrTTTT + 171b TTTVrVTRTTT + 1727 !'tegUTTT[TMTUTTTTT~TTT + 1746 TTTT~TTT + 1757 UTRTTTUrTTTT + 1769 TTTVrVTRTTT + 1775 !'te`UTTTDTMTUTTTTT~TTT + 1794 TTTT~TTT + 17a5 UTRTTTUrTTTT + 17b7 TTTVrVU^TTT + 17c7 57?'VTTTETFT + 17d6 UTTTTT~TTT + 17e8 TTTTTTTTTTTTTTTT + 17f9 UTRTTTUrTTTT + 180b TTTVrVTXTTT + 181b 57?'z + 1822 UTTTETHTUTTTTT~TTT + 183c TTTT~TTT + 184d UTRTTTUrTTTT + 185f TTTVrVTXTTT + 186f 57?'z + 1876 UTTTFTHTUTTTTT~TTT + 1890 TTTT~TTT + 18a1 UTRTTTUrTTTT + 18b3 TTTVrVU]TTT + 18bf !'tecyelVTTTGT@T + 18d1 UTTTTT~TTT + 18e3 TTTTTTTTTTTTTTTT + 18f4 UTRTTTUrTTTT + 1906 TTTVrVTRTTT + 1912 !'tecUTTTGTKTUTTTTT~TTT + 1931 TTTT~TTT + 1942 UTRTTTUrTTTT + 1954 TTTVrVTRTTT + 1960 !'telUTTT@TKTUTTTTT~TTT + 197f TTTT~TTT + 1990 UTRTTTUrTTTT + 19a2 TTTVrVUWTTT + 19b0 VTTTATBT + 19ba UTTTTT~TTT + 19cc TTTTTTTTTTTTTTTT + 19dd UTRTTTUrTTTT + 19ef TTTVrVTQTTT + 19ff UTTTATvTUTTTTT~TTT + 1a19 TTTT~TTT + 1a2a UTRTTTUrTTTT + 1a3c TTTVrVTQTTT + 1a4c UTTTBTvTUTTTTT~TTT + 1a66 TTTT~TTT + 1a77 UTRTTTUrTTTT + 1a89 TTTVrVU]TTT + 1a95 !'tfeyffVTTTCTLT + 1aa7 UTTTTT~TTT + 1ab9 TTTTTTTTTTTTTTTT + 1aca UTRTTTUrTTTT + 1adc TTTVrVTRTTT + 1ae8 !'tfeUTTTCTqTUTTTTT~TTT + 1b07 TTTT~TTT + 1b18 UTRTTTUrTTTT + 1b2a TTTVrVTRTTT + 1b36 !'tffUTTTLTqTUTTTTT~TTT + 1b55 TTTT~TTT + 1b66 UTRTTTUrTTTT + 1b78 TTTVrVU]TTT + 1b88 185-VTTTMTNT + 1b96 UTTTTT~TTT + 1ba8 TTTTTTTTTTTTTTTT + 1bb9 UTRTTTUrTTTT + 1bcb TTTVrVT_TTT + 1bdb 185-z + 1be1 UTTTMT|TUTTTTT~TTT + 1bfb TTTT~TTT + 1c0c UTRTTTUrTTTT + 1c1e TTTVrVT_TTT + 1c2e 185-z + 1c34 UTTTNT|TUTTTTT~TTT + 1c4e TTTT~TTT + 1c5f UTRTTTUrTTTT + 1c71 VTTVrVUSTTT + 1c83 VTTTOTHT + 1c8d UUTTTT~TTT + 1c9e &TTTTTTTTTTTTTTTT + 1cb0 UTWVTTUr\TTT + 1cbd RTaTTTTrpPTTV + 1ccc TTTT~TTT + 1cd6 @UTp + 1cdb *%STTT + 1ce2 ! teyfUUTTTTUUUUUTTTTT + 1cf9 RTaTTTTrpPTT? + 1d09 TTTT~TTTu=PT + 1d18 USTTT + 1d1e ! teyfUUTTTTUUUUUTTTTT + 1d35 RTaTTTTrrP + 1d43 ~ TTTT~TTTYV + 1d55 STTT + 1d60 UUTTTTUUUUUTTTTT + 1d74 TTTTrpP + 1d7f ~ TTTT~TTT + 1d91 LTTT + 1d96 &;: t + 1d9c 12 t{t + 1da3 &;: t + 1da9 =3< UUTTTTUUUUUTTTTT + 1dbe RTaTTTTrqP + 1dcc ~ TTTT~TTT + 1dde STTT + 1de9 UUTTTTUUUUUTTTTT + 1dfd TTTTr_P + 1e08 ~ TTTT~TTTx + 1e19 0GTTT + 1e1f !=8 y=:t + 1e28 ! $! teyfUUTTTTUUUUUTTTTT + 1e42 RTaTTTTrqP + 1e52 TTTT~TTTYV + 1e62 STTT + 1e6d UUTTTTUUUUUTTTTT + 1e7e RTaTTTTrsP + 1e8c ~ TTTT~TTTYV + 1e9e STTT + 1ea9 UUTTTTUUUUUTTTTT + 1ebf TTTVrVT]TTT + 1ed3 UTTTOT + 1eda TUTTTTT~TTT + 1eec &TTTT~TTT + 1efe UTRTTTUrTTTT + 1f10 TTTVrVT]TTT + 1f24 UTTTHT + 1f2b TUTTTTT~TTT + 1f3d &TTTT~TTT + 1f4f UTRTTTUrTTTT + 1f61 TTTVrVUUTTTeVTTTITJT + 1f77 UTTTTT~TTT + 1f88 &TTTTTTTTTTTTTTTT + 1f9a UTRTTTUrTTTT + 1fac TTTVrVTWTTTez + 1fba UTTTITzTUTTTTT~TTT + 1fd3 &TTTT~TTT + 1fe5 UTRTTTUrTTTT + 1ff7 TTTVrVTWT + 2398 |"h3 + 23e3 |Sh3 + 24c4 |vk3 + 251b |Zm3 + 2582 |Zm3 + 25c9 |kn3 + 25d9 |Zm3 + 32cc %ch43l + 34c6 Ap-/ + 400d PUPPP + 401d PPPq@RQYPPP + 4029 %#pba}bbRPPPGPHP + 403b QPPPPzPPP + 4051 PYPPP + 4057 %#pba}bbQP + 4062 WPiPPPq@RPVPPP + 4071 %#pbaQPPPGPuPQPPPPzPPP + 4094 PVPPP + 409a %#pbaPP + 40a2 WPiPPPq@RPVPPP + 40b1 %#pbbQPPPHPuPQPPPPzPPP + 40d4 PVPPP + 40da %#pbbPP + 40e5 PPPq@RQYPPP + 40f5 5<1)RPPPIPJP + 4103 QPPPPzPPP + 4119 PYPPP + 4123 5<1)QP + 412d PPPq@RP[PPP + 413d 5<1)~ + 4143 QPPPIPxPQPPPPzPPP + 4161 P[PPP + 416b 5<1)~ + 4177 PPPq@RP[PPP + 4187 5<1)~ + 418d QPPPJPxPQPPPPzPPP + 41ab P[PPP + 41b5 5<1)~ + 41be WPaPPPq@RQQPPPaRPPPMPNP + 41d7 QPPPPzPPP + 41e7 "PPP + 41ed PQPPPaQP + 41f6 WPcPPPq@RPSPPPa~ + 4207 QPPPMP~PQPPPPzPPP + 421f "PPP + 4225 PSPPPa~ + 4230 WPcPPPq@RPSPPPa~ + 4241 QPPPNP~PQPPPPzPPP + 4259 "PPP + 425f PSPPPa~ + 426a WPiPPPq@RQUPPP + 4279 5<1)RPPPOPpP + 4287 QPPPPzPPP + 4297 "PPP + 429d PUPPP + 42a3 5<1)QP + 42aa WPkPPPq@RPWPPP + 42b9 5<1)~ + 42bf QPPPOPaPQPPPPzPPP + 42d7 "PPP + 42dd PWPPP + 42e3 5<1)~ + 42ec WPkPPPq@RPWPPP + 42fb 5<1)~ + 4301 QPPPpPaPQPPPPzPPP + 4319 "PPP + 431f PWPPP + 4325 5<1)~ + 4331 PPPq@RQ]PPP + 433d ?#$p + 4342 $13;#pbRPPPqPrP + 4353 QPPPPzPPP + 4363 "PPP + 4369 P]PPP + 436f ?#$p + 4374 $13;#pbQP + 4381 PPPq@RP_PPP + 438d ?#$p + 4392 $13;#pb~ + 439b QPPPqPdPQPPPPzPPP + 43b3 "PPP + 43b9 P_PPP + 43bf ?#$p + 43c4 $13;#pb~ + 43d3 PPPq@RP_PPP + 43df ?#$p + 43e4 $13;#pb~ + 43ed QPPPrPdPQPPPPzPPP + 4405 "PPP + 440b P_PPP + 4411 ?#$p + 4416 $13;#pb~ + 4422 WPoPPPq@RQXPPP + 4438 RPPPsPtP + 4442 QPPPPzPPP + 4452 "PPP + 4458 PXPPP + 446b PPPq@RPZPPP + 4480 QPPPsPgPQPPPPzPPP + 4498 "PPP + 449e PZPPP + 44b3 PPPq@RPZPPP + 44c8 QPPPtPgPQPPPPzPPP + 44e0 "PPP + 44e6 PZPPP + 44f8 WPaPPPq@RQQPPPbRPPPuPvP + 4511 QPPPPzPPP + 4521 "PPP + 4527 PQPPPbQP + 4530 WPcPPPq@RPSPPPb~ + 4541 QPPPuPjPQPPPPzPPP + 4559 "PPP + 455f PSPPPb~ + 456a WPcPPPq@RPSPPPb~ + 457b QPPPvPjPQPPPPzPPP + 4593 "PPP + 4599 PSPPPb~ + 45a4 WPaPPPq@RQQPPPcRPPPwPxP + 45bd QPPPPzPPP + 45cd "PPP + 45d3 PQPPPcQP + 45dc WPcPPPq@RPSPPPc~ + 45ed QPPPwPmPQPPPPzPPP + 4605 "PPP + 460b PSPPPc~ + 4616 WPcPPPq@RPSPPPc~ + 4627 QPPPxPmPQPPPPzPPP + 463f "PPP + 4645 PSPPPc~ + 4653 PPPq@RQ]PPP + 465f %$?=1$54 + 4668 5"2RPPPyPzP + 4675 QPPPPzPPP + 4685 "PPP + 468b P]PPP + 4691 %$?=1$54 + 469a 5"2QP + 46a3 PPPq@RP_PPP + 46af %$?=1$54 + 46b8 5"2~ + 46bd QPPPyP + 46c4 PQPPPPzPPP + 46d5 "PPP + 46db P_PPP + 46e1 %$?=1$54 + 46ea 5"2~ + 46f5 PPPq@RP_PPP + 4701 %$?=1$54 + 470a 5"2~ + 470f QPPPzP + 4716 PQPPPPzPPP + 4727 "PPP + 472d P_PPP + 4733 %$?=1$54 + 473c 5"2~ + 4744 WPkPPPq@RQVPPP + 4756 %#RPPPcPdP + 4762 QPPPPzPPP + 4770 K,^PPP + 4778 PVPPP + 4781 %#QP + 4789 PPPq@RQ[PPP + 4796 5"2p + 479b %#paRPPPePfP + 47a9 QPPPPzPPP + 47b7 e,^PPP + 47bf P[PPP + 47c6 5"2p + 47cb %#paQP + 47d2 WPmPPPq@RPXPPP + 47e1 5&5"2paQPPPeP + 47ef PQPPPPzPPP + 4800 FPPP + 4806 PXPPP + 480c 5&5"2paPP + 4819 PPPq@RQ[PPP + 4826 5"2p + 482b %#pcRPPPgPhP + 4839 QPPPPzPPP + 4847 m,^PPP + 484f P[PPP + 4856 5"2p + 485b %#pcQP + 4862 WPoPPPq@RPYPPP + 4871 =29p + 4876 5"2QPPPgP + 4880 PQPPPPzPPP + 4891 FPPP + 4897 PYPPP + 489d =29p + 48a2 5"2PP + 48a8 WPkPPPq@RQVPPP + 48b7 8?"%#RPPPiPjP + 48c6 QPPPPzPPP + 48d5 ,^PPP + 48dc PVPPP + 48e2 8?"%#QP + 48ea WPkPPPq@RPWPPP + 48f9 ?%2<5"QPPPiP + 4906 PQPPPPzPPP + 4917 FPPP + 491d PWPPP + 4923 ?%2<5"PP + 492c WPiPPPq@RPVPPP + 493b <1>75QPPPjP + 4947 PQPPPPzPPP + 4958 FPPP + 495e PVPPP + 4964 <1>75PP + 496c WPgPPPq@RQTPPP + 497b 9#$RPPPkPlP + 4988 QPPPPzPPP + 4997 ,^PPP + 499e PTPPP + 49a4 9#$QP + 49ad PPPq@RQ\PPP + 49ba 5<1)p + 49c0 %#pbRPPPoP + 49ce QPPPPzPPP + 49db {,^PPP + 49e4 P\PPP + 49eb 5<1)p + 49f1 %#pbQP + 49fb PPPq@RPZPPP + 4a08 5<1)pa + 4a0f hQPPPoP + 4a17 PQPPPPzPPP + 4a28 FPPP + 4a2e PZPPP + 4a35 5<1)pa + 4a43 PPPq@RP[PPP + 4a50 5<1)pa + 4a57 afQPPP + 4a60 PQPPPPzPPP + 4a71 FPPP + 4a77 P[PPP + 4a7e 5<1)pa + 4a85 afPP + 4a8d PPPq@SQZPPP + 4a99 >#5"$pa}bRPPPQPRP + 4aac QPPPPzPPP + 4abb .!PPP + 4ac2 PZPPP + 4ac8 >#5"$pa}bQP + 4ad4 WPmPPPq@SPXPPP + 4ae3 >#5"$paQPPPQP + 4af1 PQPPPPzPPP + 4b01 .!PPP + 4b08 PXPPP + 4b0e >#5"$paPP + 4b18 WPmPPPq@SPXPPP + 4b27 >#5"$pbQPPPRP + 4b35 PQPPPPzPPP + 4b40 DQP + 4b45 .!PPP + 4b4c PXPPP + 4b52 >#5"$pbPPPPPP + 4b60 APeRPPcp + 4b6c [PPP + 4b86 [PPPTPTP + 4ba0 PPRPPPPPPPPPPPPPPPPPPPQQSPQ + 4bc7 PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPzPPP + 4bf4 DQPt + 4bf9 .!PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPzPPP + 4c34 DQPt + 4c39 .!_PPPPPPPzPPP9 + 4c4e kPPPPzPPP9 + 4c5e kPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPQPPPQPPPQPPPPPPPWPPP + 4d44 %$pa}bRPSPPPQQQTPPP + 4d5f TPPP + 4d6b SPPPTPQQQTPQQQTPQQQTPQQQPPPPzPPP + 4d8c DQPt + 4d91 .!PPPPPPPP + 4d9c QPVPPPPpPPPP + 4da9 QPVPPPdvPPPP + 4db6 QPVPPP + 4dbd @PPPP + 4dc6 PPPTpQPPP + 4dd3 PPPUpPPPPQPPP + 4de1 SP PPPVp + 4deb YPPP + 4df0 "9<91>paP + 4e01 pPYPPP + 4e08 "9<91>paPPPP + 4e15 QPhPPP + 4e1c pPPYPPP + 4e24 "9<91>paQ + 4e2e TPOPPP + 4e35 pQQPPPPPPPPPPP + 4e52 +PPPP + 4e58 RP^QPPHw + 4e64 PPPIvUPPP + 4e6e 5= ?PPQPPPPzPPP + 4e94 $PPPPPPPPQPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP + 4ec3 QPrPPPQ + 4ecb PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPs-N + 4eff PPPxp + 4f05 5= ?RP + 4f0c PPPQPPPPPPP + 4f18 ?>#$QP~PPP + 4f25 QPDPPPPQPPPPPPPPP@ + 4f3a PPPPQPPPPPP + 4f49 ^PPPPPPPPPPPPPPPPPPP + 4f61 PPPPPP + 4f70 PPPxp + 4f76 5= ?RP + 4f7d PPPQPPPPPPP + 4f89 ?>#$QP~PPP + 4f96 QPDPPPPQPPPPPPPPP@ + 4fab PPPPQPPPPPP + 4fba ^PPPPPPPPPPPPPPPPPPP + 4fd6 PPPIw + 4fdf PPPIvUPPP + 4fe9 5$5"PPQPPPPzPPP + 50e9 jr_T + 569e kr_` + 5776 [[[[ + 57e7 [[[[ + 58fd [[[[ + 5cbf [[[[ + 5ec4 [[[[ + 6940 baaaaa + 7000 ELLL + 7005 9?8#!lx{LL + 7010 ML]LLLGoELLL + 701d 9?8#!lxtLL + 7028 MLJLLLIoLLLL + 7040 MLzLLL + 7047 lLHLHLMLLLLLNLMLMLMLOLLLLLNLLLOLLLLLLLLLLLLLLLLLLLMML + 707d DLdLLL + 7086 MLXLLL]l + 7093 NLLiNLL(LLLLLHLILMMdLMDL + 70af LLLIi + 70b5 MLXLLL]l + 70c2 LLLuMLL + 70ca MLLLLMMMLL + 70d8 LLLNiMMLM + 70e2 NLwLLLq\ LLLLLLLL + 70f6 LLLLL + 70fe ILLLOLLLNLLLLLLLLLLL(LLLLLLL(LLLLLLLMLL(L(LLLLLLML + 7131 BLLLLL + 7138 OLLLLLLLLML(LL + 7147 OLLLLLLLL~ + 7152 ILLLLMLLLMLLLLLLLLLLLLL(LLLML3LLLLpLL + 7178 MLQLLLfi + 7181 MLXLLL]l + 718e NLL|MLL{LLLLL + 719f LLLMiM + 71aa ILLLLLLLL + 71b5 ILALLLllll|0l|0l~x|FLLLll|v||b}||BLLL||v||v||v|}b||GLLLllll|g|}b||GLLLllllllll}||ILMLLLlMLLLlMLLLlMLLLlMLLLl_LhL[LgLL + 722b |LLOLLLLLL + 7236 MLCLLLdh + 723f MLJLLL + 7246 \LLLL + 724c MLCLLLbh + 7255 MLJLLL + 725c \LLLL + 7262 MLCLLL|h + 726b MLJLLL + 7272 \LLLL + 7278 MLJLLLhhLLLL + 7285 MLJLLLjhLLLL + 7292 MLQLLLKi + 729b MLXLLL]l + 72a8 MLLEMLL&LLLLL + 72b6 KL{LLLDi7"LL6"LLLLLL + 72ce LL,9.OKLLLKLLL + 72dd )*-9 8 + 72e9 LLLLLMLLLM + 72f4 NL{LLL + 7300 M >LL + 7306 OLWLLLEiLLLLLLLL + 731a LLLLLLLLLLLLLLLLLLMMLLL + 7332 OLFLLLKmLLLLLLLL + 7343 MLJLLLSkLLLL + 7350 ML[MLL|iOLLLMLLOLLLLMMOLLLLLLOLLLILLL@LLLlll}0l|0l|||FLLLll|v||b||}BLLL||v||v|}v||b||GLLLllll}g||b||MLLL}ILLL@LLLlll|0l|0lxt|FLLLll|v|}b|||BLLL||v||v|}v||b||GLLLllll}g||b||GLLLllllll}||||ILLL@LLLlll~0l|0l|||FLLLll|v|yb|||BLLL||v||v|yv||b||GLLLlll~|g||b||GLLLllllluz||||OLLL + 7465 LLLL + 746e TLnLLLZiLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL + 749a LLLZkMLLL + 74a4 ML{LLLYkYLLL?)??%#" + 74b8 )8-(-8- + 74c0 -?)zxBLLL + 74d4 qAFJLLL + 74dc -?)zx + 74e5 _LLNL + 74eb LLLMLLLOL + 74f8 LLLLLMLLLMHLMLSLLLLLLLLLMLLLqC + 751a MLLLLMLLLMHLML + 7529 NLLLLLLLLMLLLH\ + 753c LLLLLMLLLMHLML + 754b NLLLLLLLLMLLLJ\ + 755e LLLLLMLLLMHLML + 756d NLLLLLLLLMLLLY\ + 7580 MLLLLMLLLMHLMLc@LLLLLLLLMLLLT\ + 75a2 LLLLLMLLLMHLML + 75b1 @LLLLLLLLMLLLn\ + 75c4 LLLLLMLLLMHLML + 75d3 zLLLLLLLLMLLLd\ + 75e6 LLLLLMLLLMHLML + 75f5 MLLLLLLLLMLLL + 7608 LLLLLMLLLMHLML + 7617 OLLLLLLLLOLLL + 762a LLLLL + 7632 OLLLLLLL + 763d JLLLLLLLMLLLMDLNL + 7653 JLLLLLLLLMLLL + 7666 LLLLLMLLLMHLML!'LLLLLLLLMLLL + 7688 LLLLLMLLLMHLML + 7697 JLLLLLLLLMLLL + 76aa MLLLLMLLLMHLMLn@LLLLLLLLMLLL + 76cc MLLLLMLLLMHLMLp@LLLLLLLLMLLL + 76ee MLLLLMLLLMHLML + 76fe LLLLLLLLMLLLLl + 7710 LLLLLMLLLMHLML + 7720 LLLLLLLLMLLLHl + 7732 LLLLLMLLLMHLML + 7742 LLLLLLLLMLLL_l + 7754 LLLLLMLLLMHLML + 7764 LLLLLLLLMLLLZl + 7776 LLLLLMLLLMHLML$ + 7786 LLLLLLLLOLLLZl + 7798 LLLLL + 77a1 LLLLLLLMis + 77ac LLLLLLLMLLLMHLML + 77be LLLLLLLLILLLZl + 77d0 LLLLL + 77d9 LLLLLLL + 77e4 LLLLLLL + 77ef LLLLLLL + 77fa LLLLLLLMLLLMHLML + 780c LLLLLLLLILLLZl + 781e LLLLL + 7827 LLLLLLL + 7832 LLLLLLL + 783d LLLLLLL*l + 7848 LLLLLLLMLLLMHLMLN + 785a LLLLLLLLMLLL[l + 786c LLLLLMLLLMHLML + 787c LLLLLLLLMLLLTl + 788e LLLLLMLLLMHLMLr + 789e LLLLLLLLMLLLUl + 78b0 LLLLLMLLLMHLMLZ + 78c0 LLLLLLLLMLLLVl + 78d2 LLLLLMLLLMHLML + 78e2 LLLLLLLLMLLLWl + 78f4 LLLLLMLLLMHLML + 7904 LLLLLLLLMLLLPl + 7916 LLLLLMLLLMHLML + 7926 LLLLLLLLMLLLQl + 7938 LLLLLMLLLMHLML + 7948 LLLLLLLLMLLLRl + 795a LLLLLMLLLMHLML + 796a LLLLLLLLMLLLSl + 797c LLLLLMLLLMHLMLW + 798c LLLLLLLLMLLLol + 799e LLLLLMLLLMHLML + 79ae LLLLLLLLMLLLhl + 79c0 LLLLLMLLLMHLML + 79cf FLLLLLLLLMLLLil + 79e2 LLLLLMLLLMHLMLUOLLLLLLLLMLLLjl + 7a04 LLLLLMLLLMHLML/NLLLLLLLLMLLLkl + 7a26 LLLLLMLLLMHLML@OLLLLLLLLMLLLdl + 7a48 LLLLLMLLLMHLML + 7a58 LLLLLLLLMLLLel + 7a6a LLLLLMLLLMHLML + 7a7a LLLLLLLLMLLLgl + 7a8c LLLLLMLLLMHLML + 7a9c LLLLLLLLMLLLal + 7aae LLLLLMLLLMHLML + 7abd /LLLLLLLLMLLLbl + 7ad0 LLLLLMLLLMHLML + 7adf /LLLLLLLLMLLL|l + 7af2 LLLLLMLLLMHLMLg(LLLLLLLLMLLL}l + 7b14 LLLLLMLLLMHLML + 7b23 GLLLLLLLLMLLL~l + 7b36 LLLLLMLLLMHLML + 7b45 NLLLLLLLLMLLL + 7b58 LLLLLMLLLMHLML + 7b68 LLLLLLLLMLLL + 7b7a LLLLLMLLLMHLML + 7b89 JLLLLLLLLMLLL + 7b9c LLLLLMLLLMHLML + 7bab JLLLLLLLLMLLL + 7bbe LLLLLMLLLMHLML4KLLLLLLLLMLLL + 7be0 LLLLLMLLLMHLMLE + 7bf0 LLLLLLLLMLLL + 7c02 LLLLLMLLLMHLML + 7c11 GLLLLLLLLMLLL + 7c24 LLLLLMLLLMHLML; + 7c34 LLLLLLLLMLLL + 7c46 LLLLLMLLLMHLML0 + 7c56 LLLLLLLLMLLL + 7c68 LLLLLMLLLMHLML + 7c77 FLLLLLLLLMLLL + 7c8a LLLLLMLLLMHLML + 7c99 OLLLLLLLLMLLL + 7cac LLLLLMLLLMHLML + 7cbc LLLLLLLLMLLL + 7cce LLLLLMLLLMHLML; + 7cde LLLLLLLLMLLL/l + 7cf0 LLLLLMLLLMHLMLfGLLLLLLLLMLLL*l + 7d12 LLLLLMLLLMHLML + 7d21 ,LLLLLLLLMLLL+l + 7d34 LLLLLMLLLMHLML + 7d43 LLLLLLLLLMLLL$l + 7d56 LLLLLMLLLMHLML?,LLLLLLLLMLLL%l + 7d78 LLLLLMLLLMHLML + 7d87 ,LLLLLLLLMLLL&l + 7d9a LLLLLMLLLMHLML + 7daa LLLLLLLLNLLL&l + 7dbc LLLLL8l + 7dc5 LLLLLLLMLLLMHLML + 7dd7 LLLLLLLLMLLL'l + 7de9 LLLLLMLLLMHLML + 7df8 ,LLLLLLLLMLLL l + 7e0b LLLLLMLLLMHLML + 7e1b LLLLLLLLMLLL!l + 7e2d LLLLLMLLLMHLML + 7e3c $LLLLLLLLMLLL"l + 7e4f LLLLLMLLLMHLML + 7e5e JLLLLLLLLMLLL=l + 7e71 LLLLLMLLLMHLML + 7e80 -LLLLLLLLMLLL>l + 7e93 LLLLLMLLLMHLML + 7ea2 .LLLLLLLLMLLL?l + 7eb5 LLLLLMLLLMHLML/KLLLLLLLLMLLL7l + 7ed7 LLLLLMLLLMHLML + 7ee7 LLLLLLLLMLLL2l + 7ef9 LLLLLMLLLMHLML + 7f08 JLLLLLLLLMLLL + 7f1b LLLLLMLLLMHLML6'LLLLLLLLMLLL + 7f3d LLLLLMLLLMHLML + 7f4c NLLLLLLLLMLLL + 7f5f LLLLLMLLLMHLML1 + 7f6f LLLLLLLLMLLL + 7f81 LLLLLMLLLMHLMLx