From 64a4689a388c401e5b24bc5c9397111a70d03922 Mon Sep 17 00:00:00 2001 From: Sorvigolova Date: Tue, 23 Jan 2018 23:22:15 +0400 Subject: [PATCH] Updated to v.0.3.0 - Added Internal keys support. - Added Signed Elf ver.2 decryption support. - Decrypting header will now use key-bruteforce method. - Options changed. - Removed Pub/Priv configs, enabled all features by default. --- PS3/internal_keys | 125 ++ PS3/keys | 1257 +++++++++++ PS3/ldr_curves | Bin 0 -> 7744 bytes PS3/vsh_curves | Bin 0 -> 360 bytes Release/scetool.exe | Bin 0 -> 256512 bytes src/README | 20 +- src/config.h | 33 +- src/elf.h | 4 +- src/frontend.cpp | 80 +- src/getopt.h | 1 - src/keys.cpp | 480 +++- src/keys.h | 32 +- src/list.cpp | 10 +- src/list.h | 10 +- src/main.cpp | 146 +- src/np.cpp | 16 +- src/np.h | 8 +- src/rvk.cpp | 6 +- src/rvk.h | 4 +- src/sce.cpp | 322 +-- src/sce.h | 114 +- src/self.cpp | 377 ++-- src/self.h | 22 +- src/tables.cpp | 70 +- src/tables.h | 13 +- src/types.h | 2 +- src/util.cpp | 13 +- src/util.h | 6 +- zlib/src/CMakeLists.txt | 249 +++ zlib/src/ChangeLog | 1472 ++++++++++++ zlib/src/Debug/adler32.obj | Bin 0 -> 6305 bytes zlib/src/Debug/compress.obj | Bin 0 -> 4508 bytes zlib/src/Debug/crc32.obj | Bin 0 -> 20602 bytes zlib/src/Debug/deflate.obj | Bin 0 -> 40329 bytes zlib/src/Debug/gzclose.obj | Bin 0 -> 3905 bytes zlib/src/Debug/gzlib.obj | Bin 0 -> 16594 bytes zlib/src/Debug/gzread.obj | Bin 0 -> 16221 bytes zlib/src/Debug/gzwrite.obj | Bin 0 -> 14028 bytes zlib/src/Debug/infback.obj | Bin 0 -> 18938 bytes zlib/src/Debug/inffast.obj | Bin 0 -> 7519 bytes zlib/src/Debug/inflate.obj | Bin 0 -> 36232 bytes zlib/src/Debug/inftrees.obj | Bin 0 -> 7415 bytes zlib/src/Debug/trees.obj | Bin 0 -> 34495 bytes zlib/src/Debug/uncompr.obj | Bin 0 -> 3691 bytes zlib/src/Debug/vc120.idb | Bin 0 -> 84992 bytes zlib/src/Debug/vc120.pdb | Bin 0 -> 86016 bytes zlib/src/Debug/zlib.log | 74 + zlib/src/Debug/zlib.tlog/CL.read.1.tlog | Bin 0 -> 35382 bytes zlib/src/Debug/zlib.tlog/CL.write.1.tlog | Bin 0 -> 8964 bytes zlib/src/Debug/zlib.tlog/Lib-link.read.1.tlog | Bin 0 -> 4730 bytes .../src/Debug/zlib.tlog/Lib-link.write.1.tlog | Bin 0 -> 2422 bytes zlib/src/Debug/zlib.tlog/cl.command.1.tlog | Bin 0 -> 10024 bytes zlib/src/Debug/zlib.tlog/lib.command.1.tlog | Bin 0 -> 2950 bytes zlib/src/Debug/zlib.tlog/zlib.lastbuildstate | 2 + zlib/src/Debug/zlibd.lib | Bin 0 -> 241282 bytes zlib/src/Debug/zutil.obj | Bin 0 -> 6176 bytes zlib/src/FAQ | 368 +++ zlib/src/INDEX | 68 + zlib/src/Makefile | 5 + zlib/src/Makefile.in | 288 +++ zlib/src/README | 115 + zlib/src/adler32.c | 179 ++ zlib/src/compress.c | 80 + zlib/src/configure | 831 +++++++ zlib/src/crc32.c | 425 ++++ zlib/src/crc32.h | 441 ++++ zlib/src/deflate.c | 1967 +++++++++++++++++ zlib/src/deflate.h | 346 +++ zlib/src/gzclose.c | 25 + zlib/src/gzguts.h | 209 ++ zlib/src/gzlib.c | 634 ++++++ zlib/src/gzread.c | 594 +++++ zlib/src/gzwrite.c | 577 +++++ zlib/src/infback.c | 640 ++++++ zlib/src/inffast.c | 340 +++ zlib/src/inffast.h | 11 + zlib/src/inffixed.h | 94 + zlib/src/inflate.c | 1512 +++++++++++++ zlib/src/inflate.h | 122 + zlib/src/inftrees.c | 306 +++ zlib/src/inftrees.h | 62 + zlib/src/make_vms.com | 867 ++++++++ zlib/src/treebuild.xml | 116 + zlib/src/trees.c | 1226 ++++++++++ zlib/src/trees.h | 128 ++ zlib/src/uncompr.c | 59 + zlib/src/zconf.h | 511 +++++ zlib/src/zconf.h.cmakein | 513 +++++ zlib/src/zconf.h.in | 511 +++++ zlib/src/zlib.3 | 151 ++ zlib/src/zlib.3.pdf | Bin 0 -> 8734 bytes zlib/src/zlib.h | 1768 +++++++++++++++ zlib/src/zlib.map | 83 + zlib/src/zlib.pc.cmakein | 13 + zlib/src/zlib.pc.in | 13 + zlib/src/zlib.sdf | Bin 0 -> 24838144 bytes zlib/src/zlib.sln | 22 + zlib/src/zlib.v12.suo | Bin 0 -> 10240 bytes zlib/src/zlib.vcxproj | 111 + zlib/src/zlib.vcxproj.filters | 99 + zlib/src/zlib.vcxproj.user | 4 + zlib/src/zlib2ansi | 152 ++ zlib/src/zutil.c | 324 +++ zlib/src/zutil.h | 253 +++ 104 files changed, 21428 insertions(+), 703 deletions(-) create mode 100644 PS3/internal_keys create mode 100644 PS3/keys create mode 100644 PS3/ldr_curves create mode 100644 PS3/vsh_curves create mode 100644 Release/scetool.exe create mode 100644 zlib/src/CMakeLists.txt create mode 100644 zlib/src/ChangeLog create mode 100644 zlib/src/Debug/adler32.obj create mode 100644 zlib/src/Debug/compress.obj create mode 100644 zlib/src/Debug/crc32.obj create mode 100644 zlib/src/Debug/deflate.obj create mode 100644 zlib/src/Debug/gzclose.obj create mode 100644 zlib/src/Debug/gzlib.obj create mode 100644 zlib/src/Debug/gzread.obj create mode 100644 zlib/src/Debug/gzwrite.obj create mode 100644 zlib/src/Debug/infback.obj create mode 100644 zlib/src/Debug/inffast.obj create mode 100644 zlib/src/Debug/inflate.obj create mode 100644 zlib/src/Debug/inftrees.obj create mode 100644 zlib/src/Debug/trees.obj create mode 100644 zlib/src/Debug/uncompr.obj create mode 100644 zlib/src/Debug/vc120.idb create mode 100644 zlib/src/Debug/vc120.pdb create mode 100644 zlib/src/Debug/zlib.log create mode 100644 zlib/src/Debug/zlib.tlog/CL.read.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/CL.write.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/Lib-link.read.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/Lib-link.write.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/cl.command.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/lib.command.1.tlog create mode 100644 zlib/src/Debug/zlib.tlog/zlib.lastbuildstate create mode 100644 zlib/src/Debug/zlibd.lib create mode 100644 zlib/src/Debug/zutil.obj create mode 100644 zlib/src/FAQ create mode 100644 zlib/src/INDEX create mode 100644 zlib/src/Makefile create mode 100644 zlib/src/Makefile.in create mode 100644 zlib/src/README create mode 100644 zlib/src/adler32.c create mode 100644 zlib/src/compress.c create mode 100644 zlib/src/configure create mode 100644 zlib/src/crc32.c create mode 100644 zlib/src/crc32.h create mode 100644 zlib/src/deflate.c create mode 100644 zlib/src/deflate.h create mode 100644 zlib/src/gzclose.c create mode 100644 zlib/src/gzguts.h create mode 100644 zlib/src/gzlib.c create mode 100644 zlib/src/gzread.c create mode 100644 zlib/src/gzwrite.c create mode 100644 zlib/src/infback.c create mode 100644 zlib/src/inffast.c create mode 100644 zlib/src/inffast.h create mode 100644 zlib/src/inffixed.h create mode 100644 zlib/src/inflate.c create mode 100644 zlib/src/inflate.h create mode 100644 zlib/src/inftrees.c create mode 100644 zlib/src/inftrees.h create mode 100644 zlib/src/make_vms.com create mode 100644 zlib/src/treebuild.xml create mode 100644 zlib/src/trees.c create mode 100644 zlib/src/trees.h create mode 100644 zlib/src/uncompr.c create mode 100644 zlib/src/zconf.h create mode 100644 zlib/src/zconf.h.cmakein create mode 100644 zlib/src/zconf.h.in create mode 100644 zlib/src/zlib.3 create mode 100644 zlib/src/zlib.3.pdf create mode 100644 zlib/src/zlib.h create mode 100644 zlib/src/zlib.map create mode 100644 zlib/src/zlib.pc.cmakein create mode 100644 zlib/src/zlib.pc.in create mode 100644 zlib/src/zlib.sdf create mode 100644 zlib/src/zlib.sln create mode 100644 zlib/src/zlib.v12.suo create mode 100644 zlib/src/zlib.vcxproj create mode 100644 zlib/src/zlib.vcxproj.filters create mode 100644 zlib/src/zlib.vcxproj.user create mode 100644 zlib/src/zlib2ansi create mode 100644 zlib/src/zutil.c create mode 100644 zlib/src/zutil.h diff --git a/PS3/internal_keys b/PS3/internal_keys new file mode 100644 index 0000000..846e8aa --- /dev/null +++ b/PS3/internal_keys @@ -0,0 +1,125 @@ +[pkg-sd] +category=PKG +revision=0000 +version=0000008400000000 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[spp-sd] +category=SPP +revision=0000 +version=0000008400000000 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[rvk-sd] +category=RVK +revision=0000 +version=0000008400000000 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[lv0ldr-sd] +category=SELF +revision=0000 +version=0000008400000000 +program_type=LV0 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[metldr-sd] +category=SELF +revision=0000 +version=0000008400000000 +program_type=LDR +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[isoldr-sd] +category=SELF +revision=0000 +version=0000008400000000 +program_type=ISO +erk=9E85BEE6D39E9632A77FE3CD6E647C8DFE4606C383E1697DD6D9CE63341EAFF9 +riv=2C1F4C82FF3A796D3A772CEEF010ECA4 +pub=625D1DF4C3264BBA9FC17A4437BA42591585A5ECCC6F3042DB3A80CBBC0426DAF33549C537AA7782 +priv=00D19A1B338041F7C31062B9C40E725E1DA5D7C11A +ctype=20 + +[lv1ldr-sd] +category=SELF +version=0000008300000000 +program_type=LV1 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[lv1ldr-sd] +category=SELF +version=0000008400000000 +program_type=LV1 +erk=014485445EC9926C50F613AE77D9C37AA99838CCEB6F75FA78E29A8C622E8011 +riv=A17D6A522CB1B08F97DA8A82E97C12F7 +pub=72C1034FC8E4C1707B7147B9E930FA3F28EBFE070B5EBFBAE4A666B498050929815CF727C6264573 +priv=008732ACD0889FF7480C5C7D9A5D3BF43C46F220F8 +ctype=11 + +[lv2ldr-sd] +category=SELF +version=0000008300000000 +program_type=LV2 +erk=FEDCBA98765432100123456789ABCDEFFEDCBA98765432100123456789ABCDEF +riv=0123456789ABCDEFFEDCBA9876543210 +pub=123DA14B3D21D82AFC759A9CF6F41610A24EC8704306BAC4E0941A5B70EEA037F1482EA7EC578872 +priv=000000000000000000000000000000000001000000 +ctype=27 + +[lv2ldr-sd] +category=SELF +version=0000008400000000 +program_type=LV2 +erk=014485445EC9926C50F613AE77D9C37AA99838CCEB6F75FA78E29A8C622E8011 +riv=A17D6A522CB1B08F97DA8A82E97C12F7 +pub=72C1034FC8E4C1707B7147B9E930FA3F28EBFE070B5EBFBAE4A666B498050929815CF727C6264573 +priv=008732ACD0889FF7480C5C7D9A5D3BF43C46F220F8 +ctype=11 + +[appldr-sd] +category=SELF +revision=0000 +version=0000008400000000 +program_type=APP +erk=014485445EC9926C50F613AE77D9C37AA99838CCEB6F75FA78E29A8C622E8011 +riv=A17D6A522CB1B08F97DA8A82E97C12F7 +pub=72C1034FC8E4C1707B7147B9E930FA3F28EBFE070B5EBFBAE4A666B498050929815CF727C6264573 +priv=008732ACD0889FF7480C5C7D9A5D3BF43C46F220F8 +ctype=11 + +[appldr-sd] +category=SELF +revision=0000 +version=0000008400000000 +program_type=UNK_7 +erk=BBDF2959EB4AAEF5882BE11FF033B77FF9FD55B1F30819D42154F6B069C14FEF +riv=241C0CC5A8591B50EF460EE3E50116C3 +pub=0E140FBAD23F1B236C6AD0623A7C2C6366AEDA66380860A9D727A56FD681F644EF22A7E07979A1BE +priv= +ctype=33 + diff --git a/PS3/keys b/PS3/keys new file mode 100644 index 0000000..d0adcbd --- /dev/null +++ b/PS3/keys @@ -0,0 +1,1257 @@ +[NP_tid] +category=OTHER +key=9B515FEACF75064981AA604D91A54E97 + +[NP_ci] +category=OTHER +key=6BA52976EFDA16EF3C339FB2971E256B + +[NP_klic_free] +category=OTHER +key=72F990788F9CFF745725F08E4C128387 + +[NP_klic_key] +category=OTHER +key=F2FBCA7A75B04EDC1390638CCDFDD1EE + +[NP_idps_const] +category=OTHER +key=5E06E04FD94A71BF0000000000000001 + +[NP_rif_key] +category=OTHER +key=DA7D4B5E499A4F53B1C1A14A7484443B + +[NP_sig] +category=OTHER +pub=E6792E446CEBA27BCADF374B99504FD8E80ADFEB3E66DE73FFE58D3291221C65018C038D3822C3C9 +priv= +ctype=2 + +[NP_rap_initial] +category=OTHER +key=869F7745C13FD890CCF29188E3CC3EDF + +[NP_rap_pbox] +category=OTHER +key=0C030604010B0F08020700050A0E0D09 + +[NP_rap_e1] +category=OTHER +key=A93E1FD67C55A329B75FDDA62A95C7A5 + +[NP_rap_e2] +category=OTHER +key=67D45DA3296D006A4E7C537BF5538C74 + +[pkg] +category=PKG +revision=0000 +version=0003005500000000 +erk=A97818BD193A67A16FE83A855E1BE9FB5640938D4DBCB2CB52C5A2F8B02B1031 +riv=4ACEF01224FBEEDF8245F8FF10211E6E +pub=41DA1A8F74FF8D3F1CE20EF3E9D8865C96014FE373CA143C9BADEDF2D9D3C7573307115CCFE04F13 +priv=00542D46E7B3DAAC8AEB81E533873AABD6D74BB710 +ctype=23 + +[spkg] +category=PKG +version=0004008200000000 +revision=0000 +erk=F8F99006F1C007D5D0B1909E9566E0E70B569399FC3394A811809FDB5CAE92CD +riv=59D28DB4ADDFB40B7D768BC9667C67B1 +pub=5432BDDD1F97418147AFF016EAA6100834F2CAA8C498B88965689EE44DF349B066CD43CBF4F2C5D0 +priv= +ctype=17 + +[spp] +category=SPP +revision=0000 +version=0003005500000000 +erk=56C655747A4B6957A2D8BB9AC605C297E6AC9871932BFECDDE066CEE5B29470A +riv=007E6B268EF1E986D10A9889CF93A8CB +pub=265C04E7F20C3B8ACAC90E7C9D12757ED7ACBC01AA6624A2A927E719A4AA1222F87D917005F6072A +priv=0001608EF3BACAFFB8C3A5958A24F758325B62B08C +ctype=22 + +[spp] +category=SPP +revision=0000 +version=0003005600000000 +erk=7FD222B3FEF467DF7E3F63AC8B77501A3B38752411E96AFEDA6587B5CD5E91B0 +riv=B889290922B002F57086B818A8FDE3CC +pub=71E12CB3D81AFA79670AF4FAC4BBE41AA7F7DDF368F5615E933CB1C21A783B73C085CA49986CCF63 +priv= +ctype=22 + +[spp] +category=SPP +revision=0000 +version=0003006100000000 +erk=ED17248214B9AB34D57ED5CA6CCAEC9879137B4B46CE5064E6491D34001BACF2 +riv=3E05572881C5BC845D310EAC28497B08 +pub=504F905A8AAAA0E9BF55F6D5285697E2CABDB1A5240C4745BE8923308169EAB43E1BFD265F5E579E +priv= +ctype=13 + +[spp] +category=SPP +revision=0000 +version=0003006600000000 +erk=E750FE8ED144D99782AC605944350B9F41AE489C3274C42C1BFD5AB06115C7C4 +riv=0F23BBED0473B4899AD793AC76D8F722 +pub=934861FF0D4BAF7141B658D1D84441D413060D7E534E99E357B5090EECFB34D947694ADB9F6E7D3F +priv= +ctype=22 + +[spp] +category=SPP +revision=0000 +version=0003007400000000 +erk=4B1A459AF1D484DABD727BD316351A9A1B3404E9B1DE925B95527166DB3BB2D0 +riv=3B6203C2730D283F978A12D5390DD747 +pub=0AEEB187EA76913765A15A435F2F1B15545F60794FB5244DC54801B6BABD497565ED6BF57C1A80C8 +priv= +ctype=23 + +[spp] +category=SPP +revision=0000 +version=0004001100000000 +erk=11FA6344E869787209E6806E66A7799F7128BD98AEAE95B386D4C88EDDDB3FEF +riv=67B49380C74FFB15AD929E8C819586AD +pub=5E028AC83D1BF838CEC43CA11969C72533A057BB0C3CB4A571F8E08DD5DF793CD1E1270CA6E89FB3 +priv= +ctype=04 + +[spp] +category=SPP +revision=0000 +version=0004008200000000 +erk=D2961BBFFEDAEE269B061454D6ACF262CD71BC6F5320180F0A04A07583CCF7C5 +riv=6D308B59BC9054B12C833359D31BAE77 +pub=0CDD0D1541A6B0DFD12E951578536CA60C93853B88FCE17592DC8D134B08A94AF8BB08667E2D70A5 +priv= +ctype=07 + +[rvk] +category=RVK +revision=0000 +version=0003005500000000 +erk=03AF06FD1CE6DA366361682CDF59F9708B5D7876F40A9E1E9AC2B22F51B60BDF +riv=8B5D7876F40A9E1E9AC2B22F51B60BDF +pub=9ADE7830EB74245EC357CE4F6401633E5A8048FD865F9D8F1A9189535A37623E2921427463A754F7 +priv=00245E673B039D656DA206BDAE4EAEFCBF2A8D5EAF +ctype=29 + +[rvk] +category=RVK +revision=0000 +version=0003005600000000 +erk=22628A9EC4C414D5B32F2B4BA4926089DE9A461B190FB3E4392D057C525535DE +riv=DE9A461B190FB3E4392D057C525535DE +pub=51751B9F1DA58638D2D99F67E20A1D4A454C5B042CD1D0A449A2989808002BA68FB5B7F4B5B4E63B +priv= +ctype=32 + +[rvk] +category=RVK +revision=0000 +version=0003006100000000 +erk=BCFEDBE01D445CDEF335C543703D8E9C1199FAC33DC4595D7382EAF54EF9C4C3 +riv=B20A23079516205525683D8058379CBF +pub=9859B677A5B8FCCA31A6FBA2E3220EE5E207343A58EEEE6B6CB260EB5E971352C45428E8C8398BE6 +priv= +ctype=33 + +[rvk] +category=RVK +revision=0000 +version=0003006600000000 +erk=1EBD693BD813ADDA2203DAEE0441F4146C174F68F532B3E43A48F029230EF70C +riv=501819323BFCF9FB99396B46B70A97E7 +pub=6563EA3D5694A913F24059A57B2A3645C7C8A587CF20075EFD978A048CAD7A68A8EB7E6BC4BC5448 +priv= +ctype=30 + +[rvk] +category=RVK +revision=0000 +version=0003007400000000 +erk=4AF39F7A4E214ECB270416EDD17113A23DC5AD2EDAA5FC91817EE171CDB8B9F4 +riv=0E5CB28FA2666E3ED45289DABC67DDC2 +pub=758BBF611ED6BB8C32D2A49A7AD456D585D11C74926F977737EE309F213D971404A8F9022B409371 +priv= +ctype=31 + +[rvk] +category=RVK +revision=0000 +version=0004001100000000 +erk=99E8959A4363BE9EBDBC2B9C73BCBBE627BF112883E650E3F95879C0BFFB103E +riv=182CC801794A2F7027BB76D29D598550 +pub=6319A4B7D99FD3A3332CB13F3DE44A898B6A4CF04B9C15E6166AFC7C5272AF7A4DE04E802FD2C71C +priv= +ctype=02 + +[rvk] +category=RVK +version=0004008200000000 +revision=0000 +erk=695984B7EE2EC2F77FCC3120150DCE7E4480D84480DDD8C5940AEB6F79E63D17 +riv=A8BA3E4E63B2BB06FC0CE57E3BB8FC46 +pub=7F1950C6E497E922400586EE338B41E01C906C5A6DFD75FEB5249CFA4BEC534F5CA679670A452B2A +priv= +ctype=12 + +[lv0ldr] +category=SELF +version=0000000000000000 +revision=0000 +program_type=LV0 +erk=B9F3F9E6107CFF2680A91E118C2403CF4A6F18F3C7EFD7D13D1AC4DB760BD222 +riv=B43661B9A79BAD9D8E2B046469CDA1E7 +pub=4C870BE86DDD996A92A3F7F404F33604244A1D02AB5B78BC9DAF030B78BE8867CF586171B7D45D20 +priv=002CC736C7AD06D264E9AB663EB1F35F5DC159248C +ctype=33 + +[lv0ldr] +category=SELF +revision=0000 +version=0004008200000000 +program_type=LV0 +erk=CA7A24EC38BDB45B98CCD7D363EA2AF0C326E65081E0630CB9AB2D215865878A +riv=F9205F46F6021697E670F13DFA726212 +pub=A8FD6DB24532D094EFA08CB41C9A72287D905C6B27B42BE4AB925AAF4AFFF34D41EEB54DD128700D +priv=001AD976FCDE86F5B8FF3E63EF3A7F94E861975BA3 +ctype=33 + +[metldr] +category=SELF +revision=0000 +program_type=LDR +erk=C0CEFE84C227F75BD07A7EB846509F93B238E770DACB9FF4A388F812482BE21B +riv=47EE7454E4774CC9B8960C7B59F4C14D +pub=C2D4AAF319355019AF99D44E2B58CA29252C89123D11D6218F40B138CAB29B7101F3AEB72A975019 +priv=00C5B2BFA1A413DD16F26D31C0F2ED4720DCFB0670 +ctype=20 + +[isoldr] +category=SELF +version=0000008400000000 +revision=0000 +program_type=ISO +erk=8860D0CFF4D0DC688D3223321B96B59A777E6914961488E07048DAECB020ECA4 +riv=C82D015D46CF152F1DD0C16F18B5B1E5 +pub=733918D7C888130509346E6B4A8B6CAA357AB557E814E8122BF102C14A314BF9475B9D70EAF9EC29 +priv=009BE892E122A5C943C1BB7403A67318AA9E1B286F +ctype=36 + +[isoldr] +category=SELF +version=0003003000000000 +revision=0001 +program_type=ISO +erk=8860D0CFF4D0DC688D3223321B96B59A777E6914961488E07048DAECB020ECA4 +riv=C82D015D46CF152F1DD0C16F18B5B1E5 +pub=733918D7C888130509346E6B4A8B6CAA357AB557E814E8122BF102C14A314BF9475B9D70EAF9EC29 +priv=009BE892E122A5C943C1BB7403A67318AA9E1B286F +ctype=36 + +[isoldr] +category=SELF +version=0003004200000000 +revision=0001 +program_type=ISO +erk=101E27F3FA2FB53ACA924F783AD553162D56B975D05B81351A1111799F20254D +riv=8D2E9C6297B8AD252998458296AC773C +pub=138446EE0BDDA5638F97328C8956E6489CBBFE57C5961D40DD5C43BB4138F1C400A8B27204A5D625 +priv=00849DBC57D3B92F01864E6E82EB4EF0EF6311E122 +ctype=32 + +[isoldr] +category=SELF +version=0003005000000000 +revision=0001 +program_type=ISO +erk=3F2604FA27AEADFBE1AC69EB00BB16EF196C2193CBD62900FFD8C25041680843 +riv=A414AC1DB7987E43777651B330B899E1 +pub=1F4633AFDE18614D6CEF38A2FD6C4CCAC7B6EB8109D72CD066ECEBA0193EA3F43C37AE83179A4E5F +priv=0085B4B05DEBA7E6AD831653C974D95149803BB272 +ctype=33 + +[isoldr] +category=SELF +revision=0001 +version=0003005500000000 +program_type=ISO +erk=BDB74AA6E3BA2DC10B1BD7F17198399A158DBE1FA0BEA68C90FCACBE4D04BE37 +riv=0207A479B1574F8E7F697528F05D5435 +pub=917E1F1DC48A54EB5F10B38E7569BB5383628A7C906F0DCA62FDA33805C15FAB270016940A09DB58 +priv=00294411363290975BA551336D3965D88AF029A17B +ctype=03 + +[isoldr] +category=SELF +version=0003005600000000 +revision=0001 +program_type=ISO +erk=311C015F169F2A1E0757F7064B14C7C9F3A3FFEE015BD4E3A22401A2667857CE +riv=7BB8B3F5AC8E0890E3148AE5688C7350 +pub=3F040EFA2335FED5670BA4D5C3AB2D9D0B4BA69D154A0062EA995A7D21DBAF0DC5A0DAD333D1C1DD +priv= +ctype=08 + +[isoldr] +category=SELF +revision=0001 +version=0003006100000000 +program_type=ISO +erk=8474ADCA3B3244931EECEB9357841442442A1C4A4BCF4E498E6738950F4E4093 +riv=FFF9CACCC4129125CAFB240F419E5F39 +pub=098E1A53E59A95316B00D5A29C05FFEBAE41D1A8A386F9DA96F98858FD25E07BB7A3BC96A5D5B556 +priv= +ctype=03 + +[isoldr] +category=SELF +revision=0001 +version=0003006600000000 +program_type=ISO +erk=E6A21C599B75696C169EC02582BDA74A776134A6E05108EA701EC0CA2AC03592 +riv=D292A7BD57C0BB2EABBCA1252FA9EDEF +pub=2ED078A13DC4617EB550AD06E228C83C142A2D588EB5E729402D18038A14842FD65B277DCAD225A5 +priv= +ctype=08 + +[isoldr] +category=SELF +revision=0001 +version=0003007400000000 +program_type=ISO +erk=072D3A5C3BDB0D674DE209381432B20414BC9BDA0F583ECB94BD9A134176DD51 +riv=8516A81F02CF938740498A406C880871 +pub=5A778DEB5C4F12E8D48E06A2BBBBE3C90FA8C6C47DF9BDB5697FD4A8EB7941CE3F59A557E81C787D +priv= +ctype=21 + +[isoldr] +category=SELF +version=0003007400000000 +revision=0100 +program_type=ISO +erk=786FAB8A0B89474A2CB80B3EA104CCCB9E13F66B45EC499BB31865D07C661EA8 +riv=94662F13D99A9F5D211C979FFDF65FE3 +pub=912C94C252B7799CEB45DFBB73EF7CAD9BCC0793A3331BBB79E3C47C0F5C782F698065A8D4DB0D8B +priv= +ctype=0E + +[isoldr] +category=SELF +revision=0001 +version=0004001100000000 +program_type=ISO +erk=4262657A3185D9480F82C8BD2F81766FCC2C8FD7DD5EBE8657B00B939E0C75BD +riv=4F1E3EF07D893A4714B1B3D5A4E50479 +pub=4DBFCFA68B52F1D66E09AFA6C18EC65479EDBD027B6B8C6A5D85FE5C84D43EA40CEF1672078A0702 +priv= +ctype=11 + +[isoldr] +category=SELF +version=0004001100000000 +revision=0100 +program_type=ISO +erk=16AA7D7C35399E2B1BFAF68CD19D7512A7855029C08BECC4CC3F035DF7F9C70B +riv=0E50DB6D937D262CB0499136852FCB80 +pub=AEE2795BF295662A50DFAFE70D1B0B6F0A2EBB211E1323A275FC6E2D13BE4F2F10CA34784F4CF1EC +priv= +ctype=0F + +[isoldr] +category=SELF +revision=0001 +version=0004008200000000 +program_type=ISO +erk=63565DBE98C3B1A52AADC907C47130FE57A10734E84F22592670F86ED2B0A086 +riv=953F6A99891B4739358F5363A00C08B9 +pub=26BE7B02E7D65C6C21BF4063CDB8C0092FE1679D62FA1A8CCC284A1D21885473A959992537A06612 +priv= +ctype=15 + +[isoldr] +category=SELF +version=0004008200000000 +revision=0100 +program_type=ISO +erk=B96EA32CB96EA32DB96EA32CB96EA32CB96EA32CB96EA32DB96EA32CB96EA32C +riv=B96EA32CB96EA32DB96EA32DB96EA32C +pub=2D7066E68C6AC3373B1346FD76FE7D18A207C811500E65D85DB57BC4A27AD78F59FD53F38F50E151 +priv=00B96EA32CB96EA32DB96EA32CB96EA32CB96EA32E +ctype=02 + +[lv1ldr] +category=SELF +version=0003003000000000 +program_type=LV1 +erk=B9F3F9E6107CFF2680A91E118C2403CF4A6F18F3C7EFD7D13D1AC4DB760BD222 +riv=B43661B9A79BAD9D8E2B046469CDA1E7 +pub=4C870BE86DDD996A92A3F7F404F33604244A1D02AB5B78BC9DAF030B78BE8867CF586171B7D45D20 +priv=002CC736C7AD06D264E9AB663EB1F35F5DC159248C +ctype=33 + +[lv1ldr] +category=SELF +version=0003004200000000 +program_type=LV1 +erk=B880593856C8C6D2037585626A12977F50DCFCF3F132D2C89AA6E670EAFC1646 +riv=A79B05D4E37B8117A95E6E7C14FB640E +pub=7454C7CCBFC2F66C142D78A730A3A6F973CC0FB75A46FCBB390790138910A0CAC78E5E21F4DA3375 +priv=00033A699FDD2DA6CDD6CCC03B2C6145F998706F74 +ctype=34 + +[lv1ldr] +category=SELF +version=0003005000000000 +program_type=LV1 +erk=1E8EEEA9E80A729F3FA52CF523B25941EA44B4155D94E5DADC5C5A77847620C7 +riv=E034D31A80316960024D1B3D3164FDC3 +pub=7E3A196f4A5879F3A7B091A2263F7C24E1716129B580566D308D9C2254B36AEE53DEF30EC85F8398 +priv=005815D17125D04C33790321DE29EB6241365100B5 +ctype=35 + +[lv1ldr] +category=SELF +version=0003005500000000 +program_type=LV1 +erk=53ABDF84BE08B0351B734F2B97D2BE1621BC6C889E4362E5C70F39D6C3ED9F23 +riv=44E652661AC7584DBE08ECB810FB5FC0 +pub=733198A7759BC07326755BC9773A8A17C8A7043C7BDAB83D88E230512E2EA3852D7DA4263A7E97F9 +priv=004312C65347ACBE95CC306442FEFD0AF4C2935EB3 +ctype=05 + +[lv1ldr] +category=SELF +version=0003005600000000 +program_type=LV1 +erk=48793EBDDA1AF65D737DA2FDA2DD104447A698F8A82CAAEE992831711BA94E83 +riv=15DCF3C67147A45D09DE7521EECA07A1 +pub=85A8868C320127F10B6598964C69221C086702021D31803520E21FDE4DBE827766BE41825CB7328C +priv= +ctype=07 + +[lv1ldr] +category=SELF +revision=0000 +version=0003006100000000 +program_type=LV1 +erk=5FF17D836E2C4AD69476E2614F64BDD05B9115389A9A6D055B5B544B1C34E3D5 +riv=DF0F50EC3C4743C5B17839D7B49F24A4 +pub=1CDABE30833823F461CA534104115FFF60010B710631E435A7D915E82AE88EDE667264656CB7062E +priv= +ctype=05 + +[lv1ldr] +category=SELF +version=0003006600000000 +program_type=LV1 +erk=BD0621FA19383C3C72ECBC3B008F1CD55FFD7C3BB7510BF11AD0CF0FC2B70951 +riv=569AF3745E1E02E3E288273CDE244CD8 +pub=21E26F11C2D69478609DD1BD278CDFC940D90386455BA52FCD1FA7E27AC2AFA826C79A10193B625C +priv= +ctype=07 + +[lv1ldr] +category=SELF +version=0003007400000000 +program_type=LV1 +erk=41A6E0039041E9D8AAF4EF2F2A2971248EDBD96A3985611ED7B4CE73EE4804FE +riv=C8C98D5A5CE23AF5607A352AECACB0DC +pub=4389664390265F96C1A882374C0F856364E33DB09BE124A4666F9A12F0DD9C811EDD55BA21ED0667 +priv= +ctype=12 + +[lv1ldr] +category=SELF +version=0004001100000000 +program_type=LV1 +erk=557EDF6C063F3272B0D44EEC12F418DA774815B5415597CC5F75C21E048BAD74 +riv=7144D7574937818517826227EF4AC0B4 +pub=085D38DBF9B757329EB862107929909D32FA1DAE60641BF4AC25319D7650597EE977F8E810FEEA96 +priv= +ctype=13 + +[lv1ldr] +category=SELF +version=0004008200000000 +program_type=LV1 +erk=10CEA04973FCCC12EC19924510822D8D4C41F657FD3D7E73F415A8D687421BCD +riv=ED8699562C6AC65204FA166257E7FCF4 +pub=9AF86FC869C159FBB62F7D9674EE257ABF12E5A96D5875B4AA73C13C2BC13E2A4079F98B9B935EE2 +priv= +ctype=14 + +[lv2ldr] +category=SELF +version=0003003000000000 +program_type=LV2 +erk=94303F69513572AB5AE17C8C2A1839D2C24C28F65389D3BBB11894CE23E0798F +riv=9769BFD187B90990AE5FEA4E110B9CF5 +pub=AFAF5E96AF396CBB69071082C46A8F34A030E8EDB799E0A7BE00AA264DFF3AEBF7923920D559404D +priv=0070ABF9361B02291829D479F56AB248203CD3EB46 +ctype=20 + +[lv2ldr] +category=SELF +version=0003004200000000 +program_type=LV2 +erk=575B0A6C4B4F2760A03FE4189EBAF4D947279FD982B14070349098B08FF92C10 +riv=411CB18F460CE50CAF2C426D8F0D93C8 +pub=3FEE313954CB3039C321A7E33B97FFDEC8988A8B55759161B04DBF4731284E4A8191E3F17D32B0EA +priv=0073076441A08CD179E5FACE349B86DA58B5B7BA78 +ctype=21 + +[lv2ldr] +category=SELF +version=0003005000000000 +program_type=LV2 +erk=6DBD48D787C58803A8D724DA5ACF04FF8FCE91D7545D2322F2B7ABF57014AF68 +riv=603A36213708520ED5D745DEC1325BA5 +pub=5888CB83AC3CCA9610BC173C53141C0CA58B93719E744660CA8823D5EAEE8F9BF736997054E4B7E3 +priv=0009EBC3DE442FA5FBF6C4F3D4F9EAB07778A142BD +ctype=22 + +[lv2ldr] +category=SELF +version=0003005500000000 +program_type=LV2 +erk=84015E90FA23139628A3C75CC09714E6427B527A82D18ABC3E91CD8D7DDAFF17 +riv=5B240444D645F2038118F97FD5A145D5 +pub=B266318245266B2D33641CD8A864066D077FAC60B7E27399099A70A683454B70F9888E7CC0C2BF72 +priv=009D4CBA2BFB1A8330D3E20E59D281D476D231C73A +ctype=0x32 + +[lv2ldr] +category=SELF +version=0003005600000000 +program_type=LV2 +erk=EAE15444048EFDE7A831BFA9F5D96F047C9FCFF50723E292CF50F5417D81E359 +riv=9CA9282DC7FA9F315EF3156D970B7CD4 +pub=0D58938CB47598A6A672874F1768068F8B80D8D17014D2ABEBAC85E5B0993D9FB6F307DDC3DDA699 +priv= +ctype=33 + +[lv2ldr] +category=SELF +version=0003006100000000 +revision=0000 +program_type=LV2 +erk=88AD367EDEC2FEED3E2F99B1C685075C41BDEC90C84F526CAF588F89BBD1CBCC +riv=8D18E8E525230E63DE10291C9DD615BF +pub=86EED1D65E58890ABDA9ACA486A2BDDB9C0A529C2053FAE301F0F698EAF443DA0F60595A597A7027 +priv= +ctype=32 + +[lv2ldr] +category=SELF +version=0003006600000000 +revision=0000 +program_type=LV2 +erk=688D5FCAC6F4EA35AC6AC79B10506007286131EE038116DB8AA2C0B0340D9FB0 +riv=75E0239D18B0B669EAE650972F99726B +pub=008E1C820AC567D1BFB8FE3CC6AD2E1845A1D1B19ED2E18B18CA34A8D28A83EC60C63859CDB3DACA +priv= +ctype=33 + +[lv2ldr] +category=SELF +version=0003007400000000 +revision=0000 +program_type=LV2 +erk=E81C5B04C29FB079A4A2687A39D4EA97BFB49D80EF546CEB292979A5F77A6254 +riv=15058FA7F2CAD7C528B5F605F6444EB0 +pub=438D0E5C1E7AFB18234DB6867472FF5F52B750F30C379C7DD1EE0FD23E417B3EA819CC01BAC480ED +priv= +ctype=11 + +[lv2ldr] +category=SELF +version=0004001100000000 +revision=0000 +program_type=LV2 +erk=A1E4B86ED02BF7F1372A2C73FE02BC738907EB37CE3BA605FE783C999FAFDB97 +riv=BBE7799B9A37CB272E386618FDFD4AEC +pub=5B31A8E2A663EBD673196E2E1022E0D64988C4E1BBFE5E474415883A3BA0D9C562A2BE9C30E9B4A8 +priv= +ctype=07 + +[lv2ldr] +category=SELF +version=0004008200000000 +program_type=LV2 +erk=0CAF212B6FA53C0DA7E2C575ADF61DBE68F34A33433B1B891ABF5C4251406A03 +riv=9B79374722AD888EB6A35A2DF25A8B3E +pub=1034A6F98AF6625CC3E3604B59B971CA617DF337538D2179EBB22F3BDC9D0C6DA56BA7DDFD205A50 +priv= +ctype=14 + +[appldr] +category=SELF +revision=0000 +version=0000008300000000 +program_type=APP +erk=95F50019E7A68E341FA72EFDF4D60ED376E25CF46BB48DFDD1F080259DC93F04 +riv=4A0955D946DB70D691A640BB7FAECC4C +pub=6F8DF8EBD0A1D1DB08B30DD3A951E3F1F27E34030B42C729C55555232D61B834B8BDFFB07E54B343 +priv=006C3E4CCB2C69A5AD7C6F60448E50C7F9184EEAF4 +ctype=21 + +[appldr] +category=SELF +revision=0001 +version=0003003000000000 +program_type=APP +erk=79481839C406A632BDB4AC093D73D99AE1587F24CE7E69192C1CD0010274A8AB +riv=6F0F25E1C8C4B7AE70DF968B04521DDA +pub=94D1B7378BAFF5DFED269240A7A364ED68446741622E50BC6079B6E606A2F8E0A4C56E5CFF836526 +priv=003DE80167D2F0E9D30F2145144A558D1174F5410C +ctype=11 + +[appldr] +category=SELF +revision=0002 +version=0003003000000000 +program_type=APP +erk=4F89BE98DDD43CAD343F5BA6B1A133B0A971566F770484AAC20B5DD1DC9FA06A +riv=90C127A9B43BA9D8E89FE6529E25206F +pub=8CA6905F46148D7D8D84D2AFCEAE61B41E6750FC22EA435DFA61FCE6F4F860EE4F54D9196CA5290E +priv=00530446451C568968EBF7068B1F45C252D70EC942 +ctype=13 + +[appldr] +category=SELF +revision=0003 +version=0003003000000000 +program_type=APP +erk=C1E6A351FCED6A0636BFCB6801A0942DB7C28BDFC5E0A053A3F52F52FCE9754E +riv=E0908163F457576440466ACAA443AE7C +pub=50022D5D37C97905F898E78E7AA14A0B5CAAD5CE8190AE5629A10D6F0CF4173597B37A95A7545C92 +priv= +ctype=0B + +[appldr] +category=SELF +revision=0004 +version=0003004200000000 +program_type=APP +erk=838F5860CF97CDAD75B399CA44F4C214CDF951AC795298D71DF3C3B7E93AAEDA +riv=7FDBB2E924D182BB0D69844ADC4ECA5B +pub=1F140E8EF887DAB52F079A06E6915A6460B75CD256834A43FA7AF90C23067AF412EDAFE2C1778D69 +priv=0074E922FDEE5DC4CDF22FC8D7986477F813400860 +ctype=14 + +[appldr] +category=SELF +revision=0005 +version=0003004200000000 +program_type=APP +erk=C109AB56593DE5BE8BA190578E7D8109346E86A11088B42C727E2B793FD64BDC +riv=15D3F191295C94B09B71EBDE088A187A +pub=B6BB0A84C649A90D97EBA55B555366F52381BB38A84C8BB71DA5A5A0949043C6DB249029A43156F7 +priv= +ctype=15 + +[appldr] +category=SELF +revision=0006 +version=0003004200000000 +program_type=APP +erk=6DFD7AFB470D2B2C955AB22264B1FF3C67F180983B26C01615DE9F2ECCBE7F41 +riv=24BD1C19D2A8286B8ACE39E4A37801C2 +pub=71F46AC33FF89DF589A100A7FB64CEAC244C9A0CBBC1FDCE80FB4BF8A0D2E66293309CB8EE8CFA95 +priv= +ctype=2C + +[appldr] +category=SELF +revision=0007 +version=0003005000000000 +program_type=APP +erk=945B99C0E69CAF0558C588B95FF41B232660ECB017741F3218C12F9DFDEEDE55 +riv=1D5EFBE7C5D34AD60F9FBC46A5977FCE +pub=AB284CA549B2DE9AA5C903B75652F78D192F8F4A8F3CD99209415C0A84C5C9FD6BF3095C1C18FFCD +priv=002CF896D35DB871D0E6A252E799876A70D043C23E +ctype=15 + +[appldr] +category=SELF +revision=0008 +version=0003005000000000 +program_type=APP +erk=2C9E8969EC44DFB6A8771DC7F7FDFBCCAF329EC3EC070900CABB23742A9A6E13 +riv=5A4CEFD5A9C3C093D0B9352376D19405 +pub=6E82F6B54A0E9DEBE4A8B3043EE3B24CD9BBB62B4416B0482582E419A2552E29AB4BEA0A4D7FA2D5 +priv= +ctype=16 + +[appldr] +category=SELF +revision=0009 +version=0003005000000000 +program_type=APP +erk=F69E4A2934F114D89F386CE766388366CDD210F1D8913E3B973257F1201D632B +riv=F4D535069301EE888CC2A852DB654461 +pub=1D7B974D10E61C2ED087A0981535904677EC07E96260F89565FF7EBDA4EE035C2AA9BCBDD5893F99 +priv= +ctype=2D + +[appldr] +category=SELF +revision=000A +version=0003005500000000 +program_type=APP +erk=29805302E7C92F204009161CA93F776A072141A8C46A108E571C46D473A176A3 +riv=5D1FAB844107676ABCDFC25EAEBCB633 +pub=09301B6436C85B53CB1585300A3F1AF9FB14DB7C30088C4642AD66D5C148B8995BB1A698A8C71827 +priv=0010818ED8A666051C6198662C3D6DDE2CA4901DDC +ctype=25 + +[appldr] +category=SELF +revision=000B +version=0003005500000000 +program_type=APP +erk=A4C97402CC8A71BC7748661FE9CE7DF44DCE95D0D58938A59F47B9E9DBA7BFC3 +riv=E4792F2B9DB30CB8D1596077A13FB3B5 +pub=2733C889D289550FE00EAA5A47A34CEF0C1AF187610EB07BA35D2C09BB73C80B244EB4147700D1BF +priv= +ctype=26 + +[appldr] +category=SELF +revision=000C +version=0003005500000000 +program_type=APP +erk=9814EFFF67B7074D1B263BF85BDC8576CE9DEC914123971B169472A1BC2387FA +riv=D43B1FA8BE15714B3078C23908BB2BCA +pub=7D1986C6BEE6CE1E0C5893BD2DF203881F40D5056761CC3F1F2E9D9A378617A2DE40BA5F09844CEB +priv= +ctype=3D + +[appldr] +category=SELF +revision=000D +version=0003005600000000 +program_type=APP +erk=03B4C421E0C0DE708C0F0B71C24E3EE04306AE7383D8C5621394CCB99FF7A194 +riv=5ADB9EAFE897B54CB1060D6885BE22CF +pub=71502ADB5783583AB88B2D5F23F419AF01C8B1E72FCA1E694AD49FE3266F1F9C61EFC6F29B351142 +priv= +ctype=12 + +[appldr] +category=SELF +revision=000E +version=0003005600000000 +program_type=APP +erk=39A870173C226EB8A3EEE9CA6FB675E82039B2D0CCB22653BFCE4DB013BAEA03 +riv=90266C98CBAA06C1BF145FF760EA1B45 +pub=84DE5692809848E5ACBE25BE548F6981E3DB14735A5DDE1A0FD1F475866532B862B1AB6A004B7255 +priv= +ctype=27 + +[appldr] +category=SELF +revision=000F +version=0003005600000000 +program_type=APP +erk=FD52DFA7C6EEF5679628D12E267AA863B9365E6DB95470949CFD235B3FCA0F3B +riv=64F50296CF8CF49CD7C643572887DA0B +pub=0696D6CCBD7CF585EF5E00D547503C185D7421581BAD196E081723CD0A97FA40B2C0CD2492B0B5A1 +priv= +ctype=3A + +[appldr] +category=SELF +revision=0010 +version=0003006100000000 +program_type=APP +erk=A5E51AD8F32FFBDE808972ACEE46397F2D3FE6BC823C8218EF875EE3A9B0584F +riv=7A203D5112F799979DF0E1B8B5B52AA4 +pub=50597B7F680DD89F6594D9BDC0CBEE03666AB53647D0487F7F452FE2DD02694631EA755548C9E934 +priv= +ctype=25 + +[appldr] +category=SELF +revision=0011 +version=0003006100000000 +program_type=APP +erk=0F8EAB8884A51D092D7250597388E3B8B75444AC138B9D36E5C7C5B8C3DF18FD +riv=97AF39C383E7EF1C98FA447C597EA8FE +pub=2FDA7A56AAEA65921C0284FF1942C6DE137370093D106034B59191951A5201B422D462F8726F852D +priv= +ctype=26 + +[appldr] +category=SELF +revision=0012 +version=0003006100000000 +program_type=APP +erk=D127E0F7F31F2546D374E46F26A45F14016308EDB409185187AB7F0B2DEE6715 +riv=25589F01B97B9BE1E07447A3CE7F06B9 +pub=3C266FF46D1F526405CCCDD67EE9C7D5693B4A072C06988CAD22ADDB64439A32E2337722F51FC15B +priv= +ctype=3D + +[appldr] +category=SELF +revision=0013 +version=0003006600000000 +program_type=APP +erk=DBF62D76FC81C8AC92372A9D631DDC9219F152C59C4B20BFF8F96B64AB065E94 +riv=CB5DD4BE8CF115FFB25801BC6086E729 +pub=B26FE6D3E3A1E766FAE79A8E6A7F48998E7FC1E4B0AD8745FF54C018C2A6CC7A0DD7525FAFEA4917 +priv= +ctype=12 + +[appldr] +category=SELF +revision=0014 +version=0003006600000000 +program_type=APP +erk=491B0D72BB21ED115950379F4564CE784A4BFAABB00E8CB71294B192B7B9F88E +riv=F98843588FED8B0E62D7DDCB6F0CECF4 +pub=04275E8838EF95BD013B223C3DF674540932F21B534C7ED2944B9104D938FEB03B824DDB866AB26E +priv= +ctype=27 + +[appldr] +category=SELF +revision=0015 +version=0003006600000000 +program_type=APP +erk=324D2BFEDA4044604EDCA550EB7F56065C4CA91DFB2636EC78030353DC1CEFF4 +riv=A37B2139FBCF62F6B41F796A594440C8 +pub=A6283C12B04C37DDC6EBBF4B31E5F1B1B2602DC83EBA6362C9C1189BF25A3EF1BB3766625A4E9694 +priv= +ctype=3A + +[appldr] +category=SELF +revision=0016 +version=0003007400000000 +program_type=APP +erk=A106692224F1E91E1C4EBAD4A25FBFF66B4B13E88D878E8CD072F23CD1C5BF7C +riv=62773C70BD749269C0AFD1F12E73909E +pub=566635D3E1DCEC47243AAD1628AE6B2CEB33463FC155E4635846CE33899C5E353DDFA47FEF5694AF +priv= +ctype=30 + +[appldr] +category=SELF +revision=0017 +version=0003007400000000 +program_type=APP +erk=4E104DCE09BA878C75DA98D0B1636F0E5F058328D81419E2A3D22AB0256FDF46 +riv=954A86C4629E116532304A740862EF85 +pub=3B7B04C71CAE2B1199D57453C038BB1B541A05AD1B94167B0AB47A9B24CAECB9000CB21407009666 +priv= +ctype=08 + +[appldr] +category=SELF +revision=0018 +version=0003007400000000 +program_type=APP +erk=1F876AB252DDBCB70E74DC4A20CD8ED51E330E62490E652F862877E8D8D0F997 +riv=BF8D6B1887FA88E6D85C2EDB2FBEC147 +pub=64A04126D77BF6B4D686F6E8F87DD150A5B014BA922D2B694FFF4453E11239A6E0B58F1703C51494 +priv= +ctype=11 + +[appldr] +category=SELF +revision=0019 +version=0004001100000000 +program_type=APP +erk=3236B9937174DF1DC12EC2DD8A318A0EA4D3ECDEA5DFB4AC1B8278447000C297 +riv=6153DEE781B8ADDC6A439498B816DC46 +pub=148DCA961E2738BAF84B2D1B6E2DA2ABD6A95F2C9571E54C6922F9ED9674F062B7F1BE5BD6FA5268 +priv= +ctype=31 + +[appldr] +category=SELF +revision=001A +version=0004001100000000 +program_type=APP +erk=5EFD1E9961462794E3B9EF2A4D0C1F46F642AAE053B5025504130590E66F19C9 +riv=1AC8FA3B3C90F8FDE639515F91B58327 +pub=BE4B1B513536960618BFEF12A713F6673881B02F9DC616191E823FC8337CCF99ADAA6172019C0C23 +priv= +ctype=17 + +[appldr] +category=SELF +revision=001B +version=0004001100000000 +program_type=APP +erk=66637570D1DEC098467DB207BAEA786861964D0964D4DBAF89E76F46955D181B +riv=9F7B5713A5ED59F6B35CD8F8A165D4B8 +pub=4AB6FB1F6F0C3D9219923C1AC683137AB05DF667833CC6A5E8F590E4E28FE2EB180C7D5861117CFB +priv= +ctype=12 + +[appldr] +category=SELF +revision=001C +version=0004008200000000 +program_type=APP +erk=CFF025375BA0079226BE01F4A31F346D79F62CFB643CA910E16CF60BD9092752 +riv=FD40664E2EBBA01BF359B0DCDF543DA4 +pub=36C1ACE6DD5CCC0006FDF3424750FAC515FC5CFA2C93EC53C6EC2BC421708D154E91F2E7EA54A893 +priv= +ctype=09 + +[appldr] +category=SELF +revision=001D +version=0004008200000000 +program_type=APP +erk=D202174EB65A62048F3674B59EF6FE72E1872962F3E1CD658DE8D7AF71DA1F3E +riv=ACB9945914EBB7B9A31ECE320AE09F2D +pub=430322887503CF52928FAAA410FD623C7321281C8825D95F5B47EF078EFCFC44454C3AB4F00BB879 +priv= +ctype=1A + +[appldr] +category=SELF +revision=0000 +version=0000008400000000 +program_type=NPDRM +erk=8E737230C80E66AD0162EDDD32F1F774EE5E4E187449F19079437A508FCF9C86 +riv=7AAECC60AD12AED90C348D8C11D2BED5 +pub=05BF09CB6FD78050C78DE69CC316FF27C9F1ED66A45BFCE0A1E5A6749B19BD546BBB4602CF373440 +priv= +ctype=0A + +[appldr] +category=SELF +revision=0001 +version=0003003000000000 +program_type=NPDRM +erk=F9EDD0301F770FABBA8863D9897F0FEA6551B09431F61312654E28F43533EA6B +riv=A551CCB4A42C37A734A2B4F9657D5540 +pub=B05F9DA5F9121EE4031467E74C505C29A8E29D1022379EDFF0500B9AE480B5DAB4578A4C61C5D6BF +priv=00040AB47509BED04BD96521AD1B365B86BF620A98 +ctype=11 + +[appldr] +category=SELF +revision=0003 +version=0003003000000000 +program_type=NPDRM +erk=1B715B0C3E8DC4C1A5772EBA9C5D34F7CCFE5B82025D453F3167566497239664 +riv=E31E206FBB8AEA27FAB0D9A2FFB6B62F +pub=3F51E59FC74D6618D34431FA67987FA11ABBFACC7111811473CD9988FE91C43FC74605E7B8CB732D +priv= +ctype=08 + +[appldr] +category=SELF +revision=0004 +version=0003004200000000 +program_type=NPDRM +erk=BB4DBF66B744A33934172D9F8379A7A5EA74CB0F559BB95D0E7AECE91702B706 +riv=ADF7B207A15AC601110E61DDFC210AF6 +pub=9C327471BAFF1F877AE4FE29F4501AF5AD6A2C459F8622697F583EFCA2CA30ABB5CD45D1131CAB30 +priv=00B61A91DF4AB6A9F142C326BA9592B5265DA88856 +ctype=16 + +[appldr] +category=SELF +revision=0006 +version=0003004200000000 +program_type=NPDRM +erk=8B4C52849765D2B5FA3D5628AFB17644D52B9FFEE235B4C0DB72A62867EAA020 +riv=05719DF1B1D0306C03910ADDCE4AF887 +pub=2A5D6C6908CA98FC4740D834C6400E6D6AD74CF0A712CF1E7DAE806E98605CC308F6A03658F2970E +priv= +ctype=29 + +[appldr] +category=SELF +revision=0007 +version=0003005000000000 +program_type=NPDRM +erk=3946DFAA141718C7BE339A0D6C26301C76B568AEBC5CD52652F2E2E0297437C3 +riv=E4897BE553AE025CDCBF2B15D1C9234E +pub=A13AFE8B63F897DA2D3DC3987B39389DC10BAD99DFB703838C4A0BC4E8BB44659C726CFD0CE60D0E +priv=009EF86907782A318D4CC3617EBACE2480E73A46F6 +ctype=17 + +[appldr] +category=SELF +revision=0009 +version=0003005000000000 +program_type=NPDRM +erk=0786F4B0CA5937F515BDCE188F569B2EF3109A4DA0780A7AA07BD89C3350810A +riv=04AD3C2F122A3B35E804850CAD142C6D +pub=A1FE61035DBBEA5A94D120D03C000D3B2F084B9F4AFA99A2D4A588DF92B8F36327CE9E47889A45D0 +priv= +ctype=2A + +[appldr] +category=SELF +revision=000A +version=0003005500000000 +program_type=NPDRM +erk=03C21AD78FBB6A3D425E9AAB1298F9FD70E29FD4E6E3A3C151205DA50C413DE4 +riv=0A99D4D4F8301A88052D714AD2FB565E +pub=3995C390C9F7FBBAB124A1C14E70F9741A5E6BDF17A605D88239652C8EA7D5FC9F24B30546C1E44B +priv=009AC6B22A056BA9E0B6D1520F28A57A3135483F9F +ctype=27 + +[appldr] +category=SELF +revision=000C +version=0003005500000000 +program_type=NPDRM +erk=357EBBEA265FAEC271182D571C6CD2F62CFA04D325588F213DB6B2E0ED166D92 +riv=D26E6DD2B74CD78E866E742E5571B84F +pub=00DCF5391618604AB42C8CFF3DC304DF45341EBA4551293E9E2B68FFE2DF527FFA3BE8329E015E57 +priv= +ctype=3A + +[appldr] +category=SELF +revision=000D +version=0003005600000000 +program_type=NPDRM +erk=337A51416105B56E40D7CAF1B954CDAF4E7645F28379904F35F27E81CA7B6957 +riv=8405C88E042280DBD794EC7E22B74002 +pub=9BFF1CC7118D2393DE50D5CF44909860683411A532767BFDAC78622DB9E5456753FE422CBAFA1DA1 +priv= +ctype=18 + +[appldr] +category=SELF +revision=000F +version=0003005600000000 +program_type=NPDRM +erk=135C098CBE6A3E037EBE9F2BB9B30218DDE8D68217346F9AD33203352FBB3291 +riv=4070C898C2EAAD1634A288AA547A35A8 +pub=BBD7CCCB556C2EF0F908DC7810FAFC37F2E56B3DAA5F7FAF53A4944AA9B841F76AB091E16B231433 +priv= +ctype=3B + +[appldr] +category=SELF +revision=0010 +version=0003006100000000 +program_type=NPDRM +erk=4B3CD10F6A6AA7D99F9B3A660C35ADE08EF01C2C336B9E46D1BB5678B4261A61 +riv=C0F2AB86E6E0457552DB50D7219371C5 +pub=64A5C60BC2AD18B8A237E4AA690647E12BF7A081523FAD4F29BE89ACAC72F7AB43C74EC9AFFDA213 +priv= +ctype=27 + +[appldr] +category=SELF +revision=0012 +version=0003006100000000 +program_type=NPDRM +erk=D2F32F6E1D7A96131FAECE657008B57AAC14A9475CEF983A55E6C82CF1FCC374 +riv=211B52440AB7066A53121106FEB29FD5 +pub=EA2F8826D1ECA47B029B41C833615006FAF535AAD30594319EA4F767925EBAE3A3EEE32E6D29580C +priv= +ctype=3A + +[appldr] +category=SELF +revision=0013 +version=0003006600000000 +program_type=NPDRM +erk=265C93CF48562EC5D18773BEB7689B8AD10C5EB6D21421455DEBC4FB128CBF46 +riv=8DEA5FF959682A9B98B688CEA1EF4A1D +pub=9D8DB5A880608DC69717991AFC3AD5C0215A5EE413328C2ABC8F35589E04432373DB2E2339EEF7C8 +priv= +ctype=18 + +[appldr] +category=SELF +revision=0015 +version=0003006600000000 +program_type=NPDRM +erk=3DED5C82E18CD9F695855B1757CA91447EA34D906A66BEAAB46113F9BCE1D92F +riv=ABF2DA36D993554FB060322DC51097F7 +pub=497296C62F2C489F9F0E7628887AD54715EFD1227B053C6AA4501D43FF6FB536B78315C08D786569 +priv= +ctype=3B + +[appldr] +category=SELF +revision=0016 +version=0003007400000000 +program_type=NPDRM +erk=7910340483E419E55F0D33E4EA5410EEEC3AF47814667ECA2AA9D75602B14D4B +riv=4AD981431B98DFD39B6388EDAD742A8E +pub=62DFE488E410B1B6B2F559E4CB932BCB78845AB623CC59FDF65168400FD76FA82ED1DC60E091D1D1 +priv= +ctype=25 + +[appldr] +category=SELF +revision=0018 +version=0003007400000000 +program_type=NPDRM +erk=1A4B32C927257811F777997EA9549CEFD2AE829A528F771A3EE7FEB2110E0133 +riv=402666C76D795D228089810DDC128D14 +pub=ABD149AB27BEE0DEC0E34BB8A8CA225E3FCF504E2DDE6A55BBD39A06CFB068CFC3CF5DF8B117EB5A +priv= +ctype=15 + +[appldr] +category=SELF +revision=0019 +version=0004001100000000 +program_type=NPDRM +erk=FBDA75963FE690CFF35B7AA7B408CF631744EDEF5F7931A04D58FD6A921FFDB3 +riv=F72C1D80FFDA2E3BF085F4133E6D2805 +pub=637EAD34E7B85C723C627E68ABDD0419914EBED4008311731DD87FDDA2DAF71F856A70E14DA17B42 +priv= +ctype=24 + +[appldr] +category=SELF +revision=001B +version=0004001100000000 +program_type=NPDRM +erk=BCF9BD763A7B787CF1428EF45546AF5EBB3D816ABA1C6FF2FFD3D854B71F355B +riv=D03979E47D236BD278EC7331B7DA0BD4 +pub=4F30DF9F3A9D6B3AF92510F81F7961DD404F5E09BFF4D989969727509E39B94A750D12A063189848 +priv= +ctype=17 + +[appldr] +category=SELF +revision=001C +version=0004008200000000 +program_type=NPDRM +erk=8103EA9DB790578219C4CEDF0592B43064A7D98B601B6C7BC45108C4047AA80F +riv=246F4B8328BE6A2D394EDE20479247C5 +pub=503172C9551308A87621ECEE90362D14889BFED2CF32B0B3E32A4F9FE527A41464B735E1ADBC6762 +priv= +ctype=30 + +[appldr] +category=SELF +revision=0000 +version=0003003000000000 +program_type=UNK_7 +erk=D91166973979EA8694476B011AC62C7E9F37DA26DE1E5C2EE3D66E42B8517085 +riv=DC01280A6E46BC674B81A7E8801EBE6E +pub=A0FC44108236141BF3517A662B027AFC1AC513A05690496C754DEB7D43BDC41B80FD75C212624EE4 +priv= +ctype=11 + +[appldr] +category=SELF +revision=0000 +version=0003004200000000 +program_type=UNK_7 +erk=B73111B0B00117E48DE5E2EE5E534C0F0EFFA4890BBB8CAD01EE0F848F91583E +riv=86F56F9E5DE513894874B8BA253334B1 +pub=B0BA1A1AB9723BB4E87CED9637BE056066BC56E16572D43D0210A06411DBF8FEB8885CD912384AE5 +priv= +ctype=12 + +[appldr] +category=SELF +revision=0000 +version=0003005000000000 +program_type=UNK_7 +erk=8E944267C02E69A4FE474B7F5FCD7974A4F936FF4355AEC4F80EFA123858D8F6 +riv=908A75754E521EAC2F5A4889C6D7B72D +pub=91201DA7D79E8EE2563142ECBD646DA026C963AC09E760E5390FFE24DAE6864310ABE147F8204D0B +priv= +ctype=13 + +[appldr] +category=SELF +revision=0000 +version=0003005500000000 +program_type=UNK_7 +erk=BB31DF9A6F62C0DF853075FAA65134D9CE2240306C1731D1F7DA9B5329BD699F +riv=263057225873F83940A65C8C926AC3E4 +pub=BC3A82A4F44C43A197070CD236FDC94FCC542D69A3E803E0AFF78D1F3DA19A79D2F61FAB5B94B437 +priv= +ctype=23 + +[appldr] +category=SELF +revision=0000 +version=0003005600000000 +program_type=UNK_7 +erk=71AA75C70A255580E4AE9BDAA0B08828C53EAA713CD0713797F143B284C1589B +riv=9DED878CB6BA07121C0F50E7B172A8BF +pub=387FCDAEAFF1B59CFAF79CE6215A065ACEAFFAF4048A4F217E1FF5CE67C66EC3F089DB235E52F9D3 +priv= +ctype=29 + +[appldr] +category=SELF +revision=0000 +version=0003006100000000 +program_type=UNK_7 +erk=F5D1DBC182F5083CD4EA37C431C7DAC73882C07F232D2699B1DD9FDDF1BF4195 +riv=D3A7C3C91CBA014FCBCA6D5570DE13FF +pub=97CA8A9781F45E557E98F176EF794FCDA6B151EB3DFD1ABA12151E00AE59957C3B15628FC8875D28 +priv= +ctype=23 + +[appldr] +category=SELF +revision=0000 +version=0003006600000000 +program_type=UNK_7 +erk=BF10F09590C0152F7EF749FF4B990122A4E8E5491DA49A2D931E72EEB990F860 +riv=22C19C5522F7A782AFC547C2640F5BDE +pub=3233BA2B284189FB1687DF653002257A0925D8EB0C64EBBE8CC7DE87F548D107DE1FD3D1D285DB4F +priv= +ctype=29 + +[appldr] +category=SELF +revision=0000 +version=0003007400000000 +program_type=UNK_7 +erk=F11DBD2C97B32AD37E55F8E743BC821D3E67630A6784D9A058DDD26313482F0F +riv=FC5FA12CA3D2D336C4B8B425D679DA55 +pub=19E27EE90E33EDAB16B22E688B5F704E5C6EC1062070EBF43554CD03DFDAE16D684BB8B5574DBECA +priv= +ctype=15 + +[appldr] +category=SELF +revision=0000 +version=0004001100000000 +program_type=UNK_7 +erk=751EE949CD3ADF50A469197494A1EC358409CCBE6E85217EBDE7A87D3FF1ABD8 +riv=23AE4ADA4D3F798DC5ED98000337FF77 +pub=1BABA87CD1AD705C462D4E7427B6DAF59A50383A348A15088F0EDFCF1ADF2B5C2B2D507B2A357D36 +priv= +ctype=1A + +[appldr] +category=SELF +revision=0000 +version=0004008200000000 +program_type=UNK_7 +erk=46BD0891224E0CE13E2162921D4BB76193AEEE4416A729FCDD111C5536BF87C9 +riv=BF036387CDB613C0AC88A6D9D2CC5316 +pub=A14F6D5F9AD7EBB3B7A39A7C32F13E5DC3B0BA16BDC33D39FDDF88F4AEEA6CFEEB0C0796C917A952 +priv= +ctype=0F + diff --git a/PS3/ldr_curves b/PS3/ldr_curves new file mode 100644 index 0000000000000000000000000000000000000000..602292a4694f56dcc9f9d6f078327955d1b60abd GIT binary patch literal 7744 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 O-jJcHHK=(r?f(PzIvKG5 literal 0 HcmV?d00001 diff --git a/PS3/vsh_curves b/PS3/vsh_curves new file mode 100644 index 0000000000000000000000000000000000000000..8eea7364576bc9671c2aec2542874b5ff70804fb GIT binary patch literal 360 zcmZQz7+CQC|NnpJE$FDwJYpoxf-Ku1Q}X`{oykeYl~qxYp6`yFFYl0ed4$gltYf z|C{{iu*{Lvvk#125SbhL@CrP<_TZfC4fk%mEwsKhyMn1eVYcj^7W+6(tpLT# a%a*Td^i%o&cK+T~w^eM~w1O9GRR91-%2j*- literal 0 HcmV?d00001 diff --git a/Release/scetool.exe b/Release/scetool.exe new file mode 100644 index 0000000000000000000000000000000000000000..1a160259cd30ee9afcc998b93d67fe617108fcaf GIT binary patch literal 256512 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

5)04O7nmeT-g9d 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 literal 0 HcmV?d00001 diff --git a/src/README b/src/README index 8088d76..83ef272 100644 --- a/src/README +++ b/src/README @@ -16,7 +16,7 @@ NP local license handling (C) 2012 by flatz type={SELF, RVK, PKG, SPP, OTHER} revision={00, ..., 18, 8000} version={..., 0001000000000000, ...} - self_type={LV0, LV1, LV2, APP, ISO, LDR, UNK_7, NPDRM} + program_type={LV0, LV1, LV2, APP, ISO, LDR, UNK_7, NPDRM} key=... erk=... riv=... @@ -28,7 +28,7 @@ NP local license handling (C) 2012 by flatz [metldr] type=SELF revision=00 - self_type=LDR + program_type=LDR erk=0000000000000000000000000000000000000000000000000000000000000000 riv=00000000000000000000000000000000 pub=00000000000000000000000000000000000000000000000000000000000000000000000000000000 @@ -60,7 +60,7 @@ OPTIONS Possible Values Explanation -v, --verbose Enable verbose output. -r, --raw Enable raw value output. -t, --template File-in Template file (SELF only) - -0, --sce-type SELF/RVK/PKG/SPP SCE File Type + -0, --category SELF/RVK/PKG/SPP SCE File Type -1, --compress-data TRUE/FALSE(default) Whether to compress data or not. -s, --skip-sections TRUE(default)/FALSE Whether to skip sections or not. -2, --key-revision e.g. 00,01,...,0A,... Key Revision @@ -68,10 +68,10 @@ OPTIONS Possible Values Explanation -K, --keyset 32(Key)16(IV) 40(Pub)21(Priv)1(CT) Override keyset. - -3, --self-auth-id e.g. 1010000001000003 Authentication ID - -4, --self-vendor-id e.g. 01000002 Vendor ID - -5, --self-type LV0/LV1/LV2/APP/ISO/ - LDR/NPDRM SELF Type + -3, --program-auth-id e.g. 1010000001000003 Authentication ID + -4, --program-vendor-id e.g. 01000002 Vendor ID + -5, --program-type LV0/LV1/LV2/APP/ISO/ + LDR/NPDRM Program Type -A, --self-app-version e.g. 0001000000000000 Application Version -6, --self-fw-version e.g. 0003004100000000 Firmware Version -7, --self-add-shdrs TRUE(default)/FALSE Whether to add ELF shdrs or not. @@ -85,6 +85,12 @@ OPTIONS Possible Values Explanation -j, --np-add-sig TRUE/FALSE(default) Whether to add a NP sig. or not. ==> History <== +Version 0.3.0 +- Added Internal keys support. +- Added Signed Elf ver.2 decryption support. +- Decrypting header will now use key-bruteforce method. +- Options changed. +- Removed Pub/Priv configs, enabled all features by default. Version 0.2.14 - Added PS3 Linux support. - Fixed ECDSA checking. diff --git a/src/config.h b/src/config.h index e591ef4..83c53a1 100644 --- a/src/config.h +++ b/src/config.h @@ -6,30 +6,8 @@ #ifndef _CONFIG_H_ #define _CONFIG_H_ -/*! scetool base version. */ -#define SCETOOL_VERSION_BASE "0.2.14" - -/*! Private build. */ -//#define CONFIG_PRIVATE_BUILD -#define BUILD_FOR "naehrwert" -//#define BUILD_FOR "unicorns" - /*! scetool version. */ -#ifdef CONFIG_PRIVATE_BUILD - #ifdef BUILD_FOR - #define SCETOOL_VERSION SCETOOL_VERSION_BASE " " - #else - #error Specify a name in BUILD_FOR. - #endif -#else - #define SCETOOL_VERSION SCETOOL_VERSION_BASE " " -#endif - -/*! Private build options. */ -//#ifdef CONFIG_PRIVATE_BUILD - #define CONFIG_CUSTOM_INDIV_SEED - #define CONFIG_DUMP_INDIV_SEED -//#endif +#define SCETOOL_VERSION "0.3.0 beta5" #if 0 /*! scetool API. */ @@ -41,15 +19,12 @@ #endif #endif -/*! NPDRM watermark text (16 bytes exactly). */ -//"I like kittens !" -#define CONFIG_NPDRM_WATERMARK "watermarktrololo" - /*! Environment variables. */ #define CONFIG_ENV_PS3 "PS3" /*! Path configurations. */ #define CONFIG_KEYS_FILE "keys" +#define CONFIG_INTERNAL_KEYS_FILE "internal_keys" #define CONFIG_KEYS_PATH "./data" #define CONFIG_CURVES_FILE "ldr_curves" #define CONFIG_CURVES_PATH "./data" @@ -74,5 +49,9 @@ #define CONFIG_NP_IDPS_CONST_KNAME "NP_idps_const" #define CONFIG_NP_RIF_KEY_KNAME "NP_rif_key" #define CONFIG_NP_SIG_KNAME "NP_sig" +#define CONFIG_NP_RAP_INITIAL_KNAME "NP_rap_initial" +#define CONFIG_NP_RAP_PBOX_KNAME "NP_rap_pbox" +#define CONFIG_NP_RAP_E1_KNAME "NP_rap_e1" +#define CONFIG_NP_RAP_E2_KNAME "NP_rap_e2" #endif diff --git a/src/elf.h b/src/elf.h index ddc5860..37919ca 100644 --- a/src/elf.h +++ b/src/elf.h @@ -925,7 +925,7 @@ typedef struct interpretation of the AUXV. Must be > 16. */ #define AT_IGNOREPPC 22 /* Entry should be ignored. */ -#define AT_SECURE 23 /* Boolean, was exec setuid-like? */ +#define AT_SECURE 23 /* boolean, was exec setuid-like? */ /* Pointer to the global system page used for system calls and other nice things. */ @@ -1463,7 +1463,7 @@ typedef struct #define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */ #define PT_MIPS_OPTIONS 0x70000002 -/* Special program header types. */ +/* Special elf program header types. */ #define PF_MIPS_LOCAL 0x10000000 diff --git a/src/frontend.cpp b/src/frontend.cpp index 0a9d7ba..b721d6a 100644 --- a/src/frontend.cpp +++ b/src/frontend.cpp @@ -2,6 +2,7 @@ * Copyright (c) 2011-2013 by naehrwert * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -30,29 +31,27 @@ extern s8 *_meta_info; extern s8 *_keyset; extern s8 *_auth_id; extern s8 *_vendor_id; -extern s8 *_self_type; +extern s8 *_program_type; extern s8 *_app_version; extern s8 *_fw_version; extern s8 *_add_shdrs; extern s8 *_ctrl_flags; extern s8 *_cap_flags; -#ifdef CONFIG_CUSTOM_INDIV_SEED extern s8 *_indiv_seed; -#endif extern s8 *_license_type; extern s8 *_app_type; extern s8 *_content_id; extern s8 *_real_fname; extern s8 *_add_sig; -static BOOL _is_hexdigit(s8 c) +static bool _is_hexdigit(s8 c) { if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) return TRUE; return FALSE; } -static BOOL _is_hexnumber(const s8 *str) +static bool _is_hexnumber(const s8 *str) { u32 i, len = strlen(str); for(i = 0; i < len; i++) @@ -61,7 +60,7 @@ static BOOL _is_hexnumber(const s8 *str) return TRUE; } -static BOOL _fill_self_config_template(s8 *file, self_config_t *sconf) +static bool _fill_self_config_template(s8 *file, self_config_t *sconf) { u8 *buf = _read_buffer(file, NULL); if(buf != NULL) @@ -74,16 +73,16 @@ static BOOL _fill_self_config_template(s8 *file, self_config_t *sconf) _LOG_VERBOSE("Template header decrypted.\n"); _LOG_VERBOSE("Using:\n"); - sconf->key_revision = _ES16(ctxt->sceh->key_revision); + sconf->key_revision = _ES16(ctxt->cfh->key_revision); _IF_VERBOSE(printf(" Key Revision 0x%04X\n", sconf->key_revision)); sconf->auth_id = _ES64(ctxt->self.ai->auth_id); _IF_VERBOSE(printf(" Auth-ID 0x%016llX\n", sconf->auth_id)); sconf->vendor_id = _ES32(ctxt->self.ai->vendor_id); _IF_VERBOSE(printf(" Vendor-ID 0x%08X\n", sconf->vendor_id)); - sconf->self_type = _ES32(ctxt->self.ai->self_type); - _IF_VERBOSE(printf(" SELF-Type 0x%08X\n", sconf->self_type)); + sconf->program_type = _ES32(ctxt->self.ai->program_type); + _IF_VERBOSE(printf(" Program-Type 0x%08X\n", sconf->program_type)); sconf->app_version = _ES64(ctxt->self.ai->version); - _IF_VERBOSE(printf(" APP Version 0x%016llX\n", sconf->app_version)); + _IF_VERBOSE(printf(" APP-Version 0x%016llX\n", sconf->app_version)); control_info_t *ci = sce_get_ctrl_info(ctxt, CONTROL_INFO_TYPE_DIGEST); ci_data_digest_40_t *cid = (ci_data_digest_40_t *)((u8 *)ci + sizeof(control_info_t)); @@ -100,16 +99,14 @@ static BOOL _fill_self_config_template(s8 *file, self_config_t *sconf) sconf->cap_flags = (u8 *)_memdup(((u8 *)oh) + sizeof(opt_header_t), 0x20); _IF_VERBOSE(_hexdump(stdout, " Capability Flags", 0, sconf->cap_flags, 0x20, 0)); -#ifdef CONFIG_CUSTOM_INDIV_SEED sconf->indiv_seed = NULL; - if(_ES32(ctxt->self.ai->self_type) == SELF_TYPE_ISO) + if(_ES32(ctxt->self.ai->program_type) == PROGRAM_TYPE_ISO) { oh = sce_get_opt_header(ctxt, OPT_HEADER_TYPE_INDIV_SEED); sconf->indiv_seed = (u8 *)_memdup(((u8 *)oh) + sizeof(opt_header_t), _ES32(oh->size) - sizeof(opt_header_t)); sconf->indiv_seed_size = _ES32(oh->size) - sizeof(opt_header_t); _IF_VERBOSE(_hexdump(stdout, " Individuals Seed", 0, sconf->indiv_seed, sconf->indiv_seed_size, 0)); } -#endif sconf->add_shdrs = TRUE; if(_add_shdrs != NULL) @@ -139,7 +136,7 @@ static BOOL _fill_self_config_template(s8 *file, self_config_t *sconf) return FALSE; } -static BOOL _fill_self_config(self_config_t *sconf) +static bool _fill_self_config(self_config_t *sconf) { if(_key_rev == NULL) { @@ -151,7 +148,7 @@ static BOOL _fill_self_config(self_config_t *sconf) printf("[*] Error (Key Revision): Please provide a valid hexadecimal number.\n"); return FALSE; } - sconf->key_revision = _x_to_u64(_key_rev); + sconf->key_revision = (u16)_x_to_u64(_key_rev); if(_auth_id == NULL) { @@ -165,20 +162,20 @@ static BOOL _fill_self_config(self_config_t *sconf) printf("[*] Error: Please specify a vendor ID.\n"); return FALSE; } - sconf->vendor_id = _x_to_u64(_vendor_id); + sconf->vendor_id = (u32)_x_to_u64(_vendor_id); - if(_self_type == NULL) + if(_program_type == NULL) { - printf("[*] Error: Please specify a SELF type.\n"); + printf("[*] Error: Please specify a program type.\n"); return FALSE; } - u64 type = _get_id(_self_types_params, _self_type); + u64 type = _get_id(_program_types_params, _program_type); if(type == (u64)(-1)) { - printf("[*] Error: Invalid SELF type.\n"); + printf("[*] Error: Invalid program type.\n"); return FALSE; } - sconf->self_type = type; + sconf->program_type = (u32)type; if(_app_version == NULL) { @@ -223,7 +220,6 @@ static BOOL _fill_self_config(self_config_t *sconf) sconf->cap_flags = _x_to_u8_buffer(_cap_flags); } -#ifdef CONFIG_CUSTOM_INDIV_SEED sconf->indiv_seed = NULL; if(_indiv_seed != NULL) { @@ -236,14 +232,13 @@ static BOOL _fill_self_config(self_config_t *sconf) sconf->indiv_seed = _x_to_u8_buffer(_indiv_seed); sconf->indiv_seed_size = len / 2; } -#endif sconf->npdrm_config = NULL; return TRUE; } -static BOOL _fill_npdrm_config(self_config_t *sconf) +static bool _fill_npdrm_config(self_config_t *sconf) { if((sconf->npdrm_config = (npdrm_config_t *)malloc(sizeof(npdrm_config_t))) == NULL) return FALSE; @@ -275,7 +270,7 @@ static BOOL _fill_npdrm_config(self_config_t *sconf) printf("[*] Error: Invalid application type.\n"); return FALSE; } - sconf->npdrm_config->app_type = type; + sconf->npdrm_config->app_type = (u32)type; if(_content_id == NULL) { @@ -334,13 +329,22 @@ void frontend_print_infos(s8 *file) } else printf("[*] Warning: Could not decrypt header.\n"); - sce_print_info(stdout, ctxt, keyset); - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF) + + cf_print_info(stdout, ctxt); + //sce_print_info(stdout, ctxt, keyset); + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) self_print_info(stdout, ctxt); - else if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_RVK && ctxt->mdec == TRUE) + else if(_ES16(ctxt->cfh->category) == CF_CATEGORY_RVK && ctxt->mdec == TRUE) rvk_print(stdout, ctxt); - else if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SPP && ctxt->mdec == TRUE) + else if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SPP && ctxt->mdec == TRUE) spp_print(stdout, ctxt); + + sce_print_info(stdout, ctxt, keyset); + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) + self_print_encrypted_info(stdout, ctxt); + if(ctxt->mdec == TRUE) + print_sce_signature_info(stdout, ctxt, keyset); + free(ctxt); } else @@ -387,14 +391,14 @@ void frontend_decrypt(s8 *file_in, s8 *file_out) if(sce_decrypt_data(ctxt)) { _LOG_VERBOSE("Data decrypted.\n"); - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) { if(self_write_to_elf(ctxt, file_out) == TRUE) printf("[*] ELF written to %s.\n", file_out); else printf("[*] Error: Could not write ELF.\n"); } - else if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_RVK) + else if(_ES16(ctxt->cfh->category) == CF_CATEGORY_RVK) { if(_write_buffer(file_out, ctxt->scebuffer + _ES64(ctxt->metash[0].data_offset), _ES64(ctxt->metash[0].data_size) + _ES64(ctxt->metash[1].data_size))) @@ -402,7 +406,7 @@ void frontend_decrypt(s8 *file_in, s8 *file_out) else printf("[*] Error: Could not write RVK.\n"); } - else if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_PKG) + else if(_ES16(ctxt->cfh->category) == CF_CATEGORY_PKG) { /*if(_write_buffer(file_out, ctxt->scebuffer + _ES64(ctxt->metash[0].data_offset), _ES64(ctxt->metash[0].data_size) + _ES64(ctxt->metash[1].data_size) + _ES64(ctxt->metash[2].data_size))) @@ -411,7 +415,7 @@ void frontend_decrypt(s8 *file_in, s8 *file_out) printf("[*] Error: Could not write PKG.\n");*/ printf("soon...\n"); } - else if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SPP) + else if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SPP) { if(_write_buffer(file_out, ctxt->scebuffer + _ES64(ctxt->metash[0].data_offset), _ES64(ctxt->metash[0].data_size) + _ES64(ctxt->metash[1].data_size))) @@ -437,7 +441,7 @@ void frontend_decrypt(s8 *file_in, s8 *file_out) void frontend_encrypt(s8 *file_in, s8 *file_out) { - BOOL can_compress = FALSE; + bool can_compress = FALSE; self_config_t sconf; sce_buffer_ctxt_t *ctxt; u32 file_len = 0; @@ -468,7 +472,7 @@ void frontend_encrypt(s8 *file_in, s8 *file_out) if(strcmp(_file_type, "SELF") == 0) { - if(_self_type == NULL && _template == NULL) + if(_program_type == NULL && _template == NULL) { printf("[*] Error: Please specify a SELF type.\n"); return; @@ -487,7 +491,7 @@ void frontend_encrypt(s8 *file_in, s8 *file_out) return; } - if(sconf.self_type == SELF_TYPE_NPDRM) + if(sconf.program_type == PROGRAM_TYPE_NPDRM) if(_fill_npdrm_config(&sconf) == FALSE) return; @@ -501,7 +505,7 @@ void frontend_encrypt(s8 *file_in, s8 *file_out) } //SPU SELFs may not be compressed. - if(!(sconf.self_type == SELF_TYPE_LDR || sconf.self_type == SELF_TYPE_ISO)) + if(!(sconf.program_type == PROGRAM_TYPE_LDR || sconf.program_type == PROGRAM_TYPE_ISO)) can_compress = TRUE; } else if(strcmp(_file_type, "RVK") == 0) @@ -547,7 +551,7 @@ void frontend_encrypt(s8 *file_in, s8 *file_out) { printf("[*] %s written.\n", file_out); //Add NPDRM footer signature. - if(sconf.self_type == SELF_TYPE_NPDRM && _add_sig != NULL && strcmp(_add_sig, "TRUE") == 0) + if(sconf.program_type == PROGRAM_TYPE_NPDRM && _add_sig != NULL && strcmp(_add_sig, "TRUE") == 0) { if(np_sign_file(file_out) == TRUE) printf("[*] Added NPDRM footer signature.\n"); diff --git a/src/getopt.h b/src/getopt.h index 19ca909..bfa7586 100644 --- a/src/getopt.h +++ b/src/getopt.h @@ -45,7 +45,6 @@ EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. #if defined(EXPORTS_GETOPT) && defined(STATIC_GETOPT) #error "The preprocessor definitions of EXPORTS_GETOPT and STATIC_GETOPT can only be used individually" #elif defined(STATIC_GETOPT) -#pragma message("Warning static builds of getopt violate the Lesser GNU Public License") #define _GETOPT_API #elif defined(EXPORTS_GETOPT) #pragma message("Exporting getopt library") diff --git a/src/keys.cpp b/src/keys.cpp index 262bddd..e8e98a4 100644 --- a/src/keys.cpp +++ b/src/keys.cpp @@ -3,6 +3,7 @@ * Copyright (c) 2012 by flatz * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -27,10 +28,10 @@ /* [keyname] -type={SELF, RVK, PKG, SPP, OTHER} +category={SELF, RVK, PKG, SPP, OTHER} revision={00, ..., 18, 8000} version={..., 0001000000000000, ...} -self_type={LV0, LV1, LV2, APP, ISO, LDR, UNK_7, NPDRM} +program_type={LV0, LV1, LV2, APP, ISO, LDR, UNK_7, NPDRM} key=... erk=... riv=... @@ -41,70 +42,54 @@ ctype=... /*! Loaded keysets. */ list_t *_keysets; -/*! Loaded curves. */ +/*! Loaded internal keysets. */ +list_t *_internal_keysets; +/*! Loaded loader curves. */ curve_t *_curves; /*! Loaded VSH curves. */ vsh_curve_t *_vsh_curves; - -static u8 rap_init_key[0x10] = -{ - 0x86, 0x9F, 0x77, 0x45, 0xC1, 0x3F, 0xD8, 0x90, 0xCC, 0xF2, 0x91, 0x88, 0xE3, 0xCC, 0x3E, 0xDF -}; - -static u8 rap_pbox[0x10] = -{ - 0x0C, 0x03, 0x06, 0x04, 0x01, 0x0B, 0x0F, 0x08, 0x02, 0x07, 0x00, 0x05, 0x0A, 0x0E, 0x0D, 0x09 -}; - -static u8 rap_e1[0x10] = -{ - 0xA9, 0x3E, 0x1F, 0xD6, 0x7C, 0x55, 0xA3, 0x29, 0xB7, 0x5F, 0xDD, 0xA6, 0x2A, 0x95, 0xC7, 0xA5 -}; - -static u8 rap_e2[0x10] = -{ - 0x67, 0xD4, 0x5D, 0xA3, 0x29, 0x6D, 0x00, 0x6A, 0x4E, 0x7C, 0x53, 0x7B, 0xF5, 0x53, 0x8C, 0x74 -}; +/*! Backup keyset. */ +keyset_t *_used_keyset; static void _fill_property(keyset_t *ks, s8 *prop, s8 *value) { - if(strcmp(prop, "type") == 0) + if(strcmp(prop, "category") == 0) { if(strcmp(value, "SELF") == 0) - ks->type = KEYTYPE_SELF; + ks->category = KEYCATEGORY_SELF; else if(strcmp(value, "RVK") == 0) - ks->type = KEYTYPE_RVK; + ks->category = KEYCATEGORY_RVK; else if(strcmp(value, "PKG") == 0) - ks->type = KEYTYPE_PKG; + ks->category = KEYCATEGORY_PKG; else if(strcmp(value, "SPP") == 0) - ks->type = KEYTYPE_SPP; + ks->category = KEYCATEGORY_SPP; else if(strcmp(value, "OTHER") == 0) - ks->type = KEYTYPE_OTHER; + ks->category = KEYCATEGORY_OTHER; else - printf("[*] Error: Unknown type '%s'.\n", value); + printf("[*] Error: Unknown category '%s'.\n", value); } else if(strcmp(prop, "revision") == 0) ks->key_revision = (u16)_x_to_u64(value); else if(strcmp(prop, "version") == 0) ks->version = _x_to_u64(value); - else if(strcmp(prop, "self_type") == 0) + else if(strcmp(prop, "program_type") == 0) { if(strcmp(value, "LV0") == 0) - ks->self_type = SELF_TYPE_LV0; + ks->program_type = PROGRAM_TYPE_LV0; else if(strcmp(value, "LV1") == 0) - ks->self_type = SELF_TYPE_LV1; + ks->program_type = PROGRAM_TYPE_LV1; else if(strcmp(value, "LV2") == 0) - ks->self_type = SELF_TYPE_LV2; + ks->program_type = PROGRAM_TYPE_LV2; else if(strcmp(value, "APP") == 0) - ks->self_type = SELF_TYPE_APP; + ks->program_type = PROGRAM_TYPE_APP; else if(strcmp(value, "ISO") == 0) - ks->self_type = SELF_TYPE_ISO; + ks->program_type = PROGRAM_TYPE_ISO; else if(strcmp(value, "LDR") == 0) - ks->self_type = SELF_TYPE_LDR; + ks->program_type = PROGRAM_TYPE_LDR; else if(strcmp(value, "UNK_7") == 0) - ks->self_type = SELF_TYPE_UNK_7; + ks->program_type = PROGRAM_TYPE_UNK_7; else if(strcmp(value, "NPDRM") == 0) - ks->self_type = SELF_TYPE_NPDRM; + ks->program_type = PROGRAM_TYPE_NPDRM; else printf("[*] Error: unknown SELF type '%s'.\n", value); } @@ -161,6 +146,29 @@ static void _sort_keysets() _keysets = tmp; } +static void _sort_internal_keysets() +{ + u32 i, to = _internal_keysets->count; + lnode_t *max; + + list_t *tmp = list_create(); + + for(i = 0; i < to; i++) + { + max = _internal_keysets->head; + LIST_FOREACH(iter, _internal_keysets) + { + if(_compare_keysets((keyset_t *)max->value, (keyset_t *)iter->value) < 0) + max = iter; + } + list_push(tmp, max->value); + list_remove_node(_internal_keysets, max); + } + + list_destroy(_internal_keysets); + _internal_keysets = tmp; +} + void _print_key_list(FILE *fp) { const s8 *name; @@ -172,21 +180,53 @@ void _print_key_list(FILE *fp) fprintf(fp, " Name"); _print_align(fp, " ", len, 4); - fprintf(fp, " Type Revision Version SELF-Type\n"); + fprintf(fp, " Category Revision Version Program-Type\n"); LIST_FOREACH(iter, _keysets) { keyset_t *ks = (keyset_t *)iter->value; fprintf(fp, " %s", ks->name); _print_align(fp, " ", len, strlen(ks->name)); - fprintf(fp, " %-5s 0x%04X %s ", _get_name(_key_types, ks->type), ks->key_revision, sce_version_to_str(ks->version)); - if(ks->type == KEYTYPE_SELF) + fprintf(fp, " %-5s 0x%04X %s ", _get_name(_key_categories, ks->category), ks->key_revision, sce_version_to_str(ks->version)); + if(ks->category == KEYCATEGORY_SELF) { - name = _get_name(_self_types, ks->self_type); + name = _get_name(_program_types, ks->program_type); if(name != NULL) fprintf(fp, "[%s]\n", name); else - fprintf(fp, "0x%08X\n", ks->self_type); + fprintf(fp, "0x%08X\n", ks->program_type); + } + else + fprintf(fp, "\n"); + } +} + +void _print_internal_key_list(FILE *fp) +{ + const s8 *name; + s32 len = 0, tmp; + + LIST_FOREACH(iter, _internal_keysets) + if((tmp = strlen(((keyset_t *)iter->value)->name)) > len) + len = tmp; + + fprintf(fp, " Name"); + _print_align(fp, " ", len, 4); + fprintf(fp, " Category Revision Version Program-Type\n"); + + LIST_FOREACH(iter, _internal_keysets) + { + keyset_t *ks = (keyset_t *)iter->value; + fprintf(fp, " %s", ks->name); + _print_align(fp, " ", len, strlen(ks->name)); + fprintf(fp, " %-5s 0x%04X %s ", _get_name(_key_categories, ks->category), ks->key_revision, sce_version_to_str(ks->version)); + if(ks->category == KEYCATEGORY_SELF) + { + name = _get_name(_program_types, ks->program_type); + if(name != NULL) + fprintf(fp, "[%s]\n", name); + else + fprintf(fp, "0x%08X\n", ks->program_type); } else fprintf(fp, "\n"); @@ -194,7 +234,7 @@ void _print_key_list(FILE *fp) } #define LINEBUFSIZE 512 -BOOL keys_load(const s8 *kfile) +bool keys_load(const s8 *kfile) { u32 i = 0, lblen; FILE *fp; @@ -263,41 +303,304 @@ BOOL keys_load(const s8 *kfile) return TRUE; } + +bool internal_keys_load(const s8 *kfile) +{ + u32 i = 0, lblen; + FILE *fp; + s8 lbuf[LINEBUFSIZE]; + keyset_t *cks = NULL; + + if((_internal_keysets = list_create()) == NULL) + return FALSE; + + if((fp = fopen(kfile, "r")) == NULL) + { + list_destroy(_internal_keysets); + return FALSE; + } + + do + { + //Get next line. + lbuf[0] = 0; + fgets(lbuf, LINEBUFSIZE, fp); + lblen = strlen(lbuf); + + //Don't parse empty lines (ignore '\n') and comment lines (starting with '#'). + if(lblen > 1 && lbuf[0] != '#') + { + //Remove '\n'. + lbuf[lblen-1] = 0; + + //Check for keyset entry. + if(lblen > 2 && lbuf[0] == '[') + { + if(cks != NULL) + { + //Add to keyset list. + list_push(_internal_keysets, cks); + cks = NULL; + } + + //Find name end. + for(i = 0; lbuf[i] != ']' && lbuf[i] != '\n' && i < lblen; i++); + lbuf[i] = 0; + + //Allocate keyset and fill name. + cks = (keyset_t *)malloc(sizeof(keyset_t)); + memset(cks, 0, sizeof(keyset_t)); + cks->name = strdup(&lbuf[1]); + } + else if(cks != NULL) + { + //Find property name end. + for(i = 0; lbuf[i] != '=' && lbuf[i] != '\n' && i < lblen; i++); + lbuf[i] = 0; + + //Fill property. + _fill_property(cks, &lbuf[0], &lbuf[i+1]); + } + } + } while(!feof(fp)); + + //Add last keyset to keyset list. + if(cks != NULL) + list_push(_internal_keysets, cks); + + //Sort keysets. + _sort_internal_keysets(); + + return TRUE; +} #undef LINEBUFSIZE -static keyset_t *_keyset_find_for_self(u32 self_type, u16 key_revision, u64 version) +static bool validate_keyset(sce_buffer_ctxt_t *ctxt, keyset_t *ks) +{ + u8 *test_buf = (u8 *)malloc(sizeof(u8) * 0x50); + u8 *test_buf2 = (u8 *)malloc(sizeof(u8) * 0x50); + u8 *iv = (u8 *)malloc(sizeof(u8) * 0x10); + u8 *sblk = (u8 *)malloc(sizeof(u8) * 0x10); + u8 *ctr_iv = (u8 *)malloc(sizeof(u8) * 0x10); + aes_context aes_ctxt; + size_t nc_off; + u64 sig_input_length; + u32 sig_algo, section_count; + + memcpy(test_buf, ctxt->metai, 0x50); + + memcpy(test_buf2, test_buf, 0x50); + nc_off = 0; + + memcpy(iv, ks->riv, 0x10); + aes_setkey_dec(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, 0x40, iv, test_buf2, test_buf2); + + nc_off = 0; + memcpy (ctr_iv, (test_buf2 + 0x20) ,0x10); + aes_setkey_enc(&aes_ctxt, test_buf2, METADATA_INFO_KEYBITS); + aes_crypt_ctr(&aes_ctxt, 0x10, &nc_off, ctr_iv, sblk, (test_buf2 + 0x40), (test_buf2 + 0x40)); + + sig_input_length = _ES64(*(u64*)&test_buf2[0x40]); + sig_algo = _ES32(*(u32*)&test_buf2[0x48]); + section_count = _ES32(*(u32*)&test_buf2[0x4C]); + + if((sig_input_length < _ES64(ctxt->cfh->file_offset)) && sig_algo == 1 && section_count < 0xFF) + return true; + + memcpy(test_buf2, test_buf, 0x50); + memcpy(iv, ks->riv, 0x10); + aes_setkey_enc(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + aes_crypt_ctr(&aes_ctxt, 0x40, &nc_off, iv, sblk, test_buf2, test_buf2); + + nc_off = 0; + memcpy (ctr_iv, (test_buf2 + 0x20) ,0x10); + aes_setkey_enc(&aes_ctxt, test_buf2, METADATA_INFO_KEYBITS); + aes_crypt_ctr(&aes_ctxt, 0x10, &nc_off, ctr_iv, sblk, (test_buf2 + 0x40), (test_buf2 + 0x40)); + + sig_input_length = _ES64(*(u64*)&test_buf2[0x40]); + sig_algo = _ES32(*(u32*)&test_buf2[0x48]); + section_count = _ES32(*(u32*)&test_buf2[0x4C]); + + if((sig_input_length < _ES64(ctxt->cfh->file_offset)) && sig_algo == 1 && section_count < 0xFF) + return true; + + return false; +} + +static keyset_t *_keyset_bruteforce_for_self(sce_buffer_ctxt_t *ctxt, u32 program_type, list_t *__keysets) +{ + LIST_FOREACH(iter, __keysets) + { + keyset_t *ks = (keyset_t *)iter->value; + + if(ks->program_type == program_type) + { + switch(program_type) + { + case PROGRAM_TYPE_LV0: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_LV1: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_LV2: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_APP: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_ISO: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_LDR: + if (validate_keyset(ctxt, ks)) + return ks; + break; + case PROGRAM_TYPE_NPDRM: + if (validate_keyset(ctxt, ks)) + return ks; + break; + } + } + } + + return NULL; +} + +static keyset_t *_keyset_bruteforce_for_rvk(sce_buffer_ctxt_t *ctxt, list_t *__keysets) +{ + LIST_FOREACH(iter, __keysets) + { + keyset_t *ks = (keyset_t *)iter->value; + + if(ks->category == KEYCATEGORY_RVK) + if (validate_keyset(ctxt, ks)) + return ks; + } + + return NULL; +} + +static keyset_t *_keyset_bruteforce_for_pkg(sce_buffer_ctxt_t *ctxt, list_t *__keysets) +{ + LIST_FOREACH(iter, __keysets) + { + keyset_t *ks = (keyset_t *)iter->value; + + if(ks->category == KEYCATEGORY_PKG) + if (validate_keyset(ctxt, ks)) + return ks; + } + + return NULL; +} + +static keyset_t *_keyset_bruteforce_for_spp(sce_buffer_ctxt_t *ctxt, list_t *__keysets) +{ + LIST_FOREACH(iter, __keysets) + { + keyset_t *ks = (keyset_t *)iter->value; + + if(ks->category == KEYCATEGORY_SPP) + if (validate_keyset(ctxt, ks)) + return ks; + } + + return NULL; +} + +keyset_t *keyset_bruteforce(sce_buffer_ctxt_t *ctxt) +{ + keyset_t *res = NULL; + + switch(_ES16(ctxt->cfh->category)) + { + case CF_CATEGORY_SELF: + res = _keyset_bruteforce_for_self(ctxt, _ES32(ctxt->self.ai->program_type), _keysets); + break; + case CF_CATEGORY_RVK: + res = _keyset_bruteforce_for_rvk(ctxt, _keysets); + break; + case CF_CATEGORY_PKG: + res = _keyset_bruteforce_for_pkg(ctxt, _keysets); + break; + case CF_CATEGORY_SPP: + res = _keyset_bruteforce_for_spp(ctxt, _keysets); + break; + } + + if(res == NULL) + { + switch(_ES16(ctxt->cfh->category)) + { + case CF_CATEGORY_SELF: + res = _keyset_bruteforce_for_self(ctxt, _ES32(ctxt->self.ai->program_type), _internal_keysets); + break; + case CF_CATEGORY_RVK: + res = _keyset_bruteforce_for_rvk(ctxt, _internal_keysets); + break; + case CF_CATEGORY_PKG: + res = _keyset_bruteforce_for_pkg(ctxt, _internal_keysets); + break; + case CF_CATEGORY_SPP: + res = _keyset_bruteforce_for_spp(ctxt, _internal_keysets); + break; + } + } + //Backup keyset. + if(res != NULL) + _used_keyset = res; + + if(res == NULL) + printf("[*] Error: Could not find keyset for %s.\n", _get_name(_cert_file_categories, _ES16(ctxt->cfh->category))); + + return res; +} + +keyset_t *get_used_keyset() +{ + return _used_keyset; +} + +static keyset_t *_keyset_find_for_self(u32 program_type, u16 key_revision, u64 version) { LIST_FOREACH(iter, _keysets) { keyset_t *ks = (keyset_t *)iter->value; - if(ks->self_type == self_type) + if(ks->program_type == program_type) { - switch(self_type) + switch(program_type) { - case SELF_TYPE_LV0: + case PROGRAM_TYPE_LV0: return ks; break; - case SELF_TYPE_LV1: + case PROGRAM_TYPE_LV1: if(version <= ks->version) return ks; break; - case SELF_TYPE_LV2: + case PROGRAM_TYPE_LV2: if(version <= ks->version) return ks; break; - case SELF_TYPE_APP: + case PROGRAM_TYPE_APP: if(key_revision == ks->key_revision) return ks; break; - case SELF_TYPE_ISO: + case PROGRAM_TYPE_ISO: if(version <= ks->version && key_revision == ks->key_revision) return ks; break; - case SELF_TYPE_LDR: + case PROGRAM_TYPE_LDR: return ks; break; - case SELF_TYPE_NPDRM: + case PROGRAM_TYPE_NPDRM: if(key_revision == ks->key_revision) return ks; break; @@ -314,7 +617,7 @@ static keyset_t *_keyset_find_for_rvk(u32 key_revision) { keyset_t *ks = (keyset_t *)iter->value; - if(ks->type == KEYTYPE_RVK && key_revision <= ks->key_revision) + if(ks->category == KEYCATEGORY_RVK && key_revision <= ks->key_revision) return ks; } @@ -327,7 +630,7 @@ static keyset_t *_keyset_find_for_pkg(u16 key_revision) { keyset_t *ks = (keyset_t *)iter->value; - if(ks->type == KEYTYPE_PKG && key_revision <= ks->key_revision) + if(ks->category == KEYCATEGORY_PKG && key_revision <= ks->key_revision) return ks; } @@ -340,7 +643,7 @@ static keyset_t *_keyset_find_for_spp(u16 key_revision) { keyset_t *ks = (keyset_t *)iter->value; - if(ks->type == KEYTYPE_SPP && key_revision <= ks->key_revision) + if(ks->category == KEYCATEGORY_SPP && key_revision <= ks->key_revision) return ks; } @@ -351,24 +654,24 @@ keyset_t *keyset_find(sce_buffer_ctxt_t *ctxt) { keyset_t *res = NULL; - switch(_ES16(ctxt->sceh->header_type)) + switch(_ES16(ctxt->cfh->category)) { - case SCE_HEADER_TYPE_SELF: - res = _keyset_find_for_self(_ES32(ctxt->self.ai->self_type), _ES16(ctxt->sceh->key_revision), _ES64(ctxt->self.ai->version)); + case CF_CATEGORY_SELF: + res = _keyset_find_for_self(_ES32(ctxt->self.ai->program_type), _ES16(ctxt->cfh->key_revision), _ES64(ctxt->self.ai->version)); break; - case SCE_HEADER_TYPE_RVK: - res = _keyset_find_for_rvk(_ES16(ctxt->sceh->key_revision)); + case CF_CATEGORY_RVK: + res = _keyset_find_for_rvk(_ES16(ctxt->cfh->key_revision)); break; - case SCE_HEADER_TYPE_PKG: - res = _keyset_find_for_pkg(_ES16(ctxt->sceh->key_revision)); + case CF_CATEGORY_PKG: + res = _keyset_find_for_pkg(_ES16(ctxt->cfh->key_revision)); break; - case SCE_HEADER_TYPE_SPP: - res = _keyset_find_for_spp(_ES16(ctxt->sceh->key_revision)); + case CF_CATEGORY_SPP: + res = _keyset_find_for_spp(_ES16(ctxt->cfh->key_revision)); break; } if(res == NULL) - printf("[*] Error: Could not find keyset for %s.\n", _get_name(_sce_header_types, _ES16(ctxt->sceh->header_type))); + printf("[*] Error: Could not find keyset for %s.\n", _get_name(_cert_file_categories, _ES16(ctxt->cfh->category))); return res; } @@ -387,7 +690,7 @@ keyset_t *keyset_find_by_name(const s8 *name) return NULL; } -BOOL curves_load(const s8 *cfile) +bool curves_load(const s8 *cfile) { u32 len = 0; @@ -412,7 +715,7 @@ curve_t *curve_find(u8 ctype) return &_curves[ctype]; } -BOOL vsh_curves_load(const s8 *cfile) +bool vsh_curves_load(const s8 *cfile) { u32 len = 0; @@ -586,39 +889,56 @@ static u8 *rap_load(const s8 *content_id) return rap; } -static BOOL rap_to_klicensee(const s8 *content_id, u8 *klicensee) +static bool rap_to_klicensee(const s8 *content_id, u8 *klicensee) { u8 *rap; aes_context aes_ctxt; int round_num; int i; + keyset_t *rap_init_key, *rap_pbox, *rap_e1, *rap_e2; + + rap_init_key = keyset_find_by_name(CONFIG_NP_RAP_INITIAL_KNAME); + if(rap_init_key == NULL) + return FALSE; + + rap_pbox = keyset_find_by_name(CONFIG_NP_RAP_PBOX_KNAME); + if(rap_pbox == NULL) + return FALSE; + + rap_e1 = keyset_find_by_name(CONFIG_NP_RAP_E1_KNAME); + if(rap_e1 == NULL) + return FALSE; + + rap_e2 = keyset_find_by_name(CONFIG_NP_RAP_E2_KNAME); + if(rap_e2 == NULL) + return FALSE; rap = rap_load(content_id); if(rap == NULL) return FALSE; - aes_setkey_dec(&aes_ctxt, rap_init_key, RAP_KEYBITS); + aes_setkey_dec(&aes_ctxt, rap_init_key->erk, RAP_KEYBITS); aes_crypt_ecb(&aes_ctxt, AES_DECRYPT, rap, rap); for (round_num = 0; round_num < 5; ++round_num) { for (i = 0; i < 16; ++i) { - int p = rap_pbox[i]; - rap[p] ^= rap_e1[p]; + int p = rap_pbox->erk[i]; + rap[p] ^= rap_e1->erk[p]; } for (i = 15; i >= 1; --i) { - int p = rap_pbox[i]; - int pp = rap_pbox[i - 1]; + int p = rap_pbox->erk[i]; + int pp = rap_pbox->erk[i - 1]; rap[p] ^= rap[pp]; } int o = 0; for (i = 0; i < 16; ++i) { - int p = rap_pbox[i]; + int p = rap_pbox->erk[i]; u8 kc = rap[p] - o; - u8 ec2 = rap_e2[p]; + u8 ec2 = rap_e2->erk[p]; if (o != 1 || kc != 0xFF) { o = kc < ec2 ? 1 : 0; @@ -637,7 +957,7 @@ static BOOL rap_to_klicensee(const s8 *content_id, u8 *klicensee) return TRUE; } -BOOL klicensee_by_content_id(const s8 *content_id, u8 *klicensee) +bool klicensee_by_content_id(const s8 *content_id, u8 *klicensee) { aes_context aes_ctxt; @@ -714,7 +1034,7 @@ BOOL klicensee_by_content_id(const s8 *content_id, u8 *klicensee) return TRUE; } -BOOL dev_klicensee_by_content_id(const s8 *content_id, u8 *klicensee) +bool dev_klicensee_by_content_id(const s8 *content_id, u8 *klicensee) { s8 *ps3 = NULL, path[256]; diff --git a/src/keys.h b/src/keys.h index ca5c06b..dbc6bc9 100644 --- a/src/keys.h +++ b/src/keys.h @@ -11,11 +11,11 @@ #define KEYBITS(klen) BYTES2BITS(klen) -#define KEYTYPE_SELF 1 -#define KEYTYPE_RVK 2 -#define KEYTYPE_PKG 3 -#define KEYTYPE_SPP 4 -#define KEYTYPE_OTHER 5 +#define KEYCATEGORY_SELF 1 +#define KEYCATEGORY_RVK 2 +#define KEYCATEGORY_PKG 3 +#define KEYCATEGORY_SPP 4 +#define KEYCATEGORY_OTHER 5 /*! Flag to use VSH curve. */ #define USE_VSH_CURVE 0x40 @@ -48,14 +48,14 @@ typedef struct _keyset { /*! Name. */ s8 *name; - /*! Type. */ - u32 type; + /*! Category. */ + u32 category; /*! Key revision. */ u16 key_revision; /*! Version. */ u64 version; - /*! SELF type. */ - u32 self_type; + /*! Program type. */ + u32 program_type; /*! Key length. */ u32 erklen; /*! Key. */ @@ -116,20 +116,24 @@ typedef struct _rif } rif_t; void _print_key_list(FILE *fp); +void _print_internal_key_list(FILE *fp); -BOOL keys_load(const s8 *kfile); +bool keys_load(const s8 *kfile); +bool internal_keys_load(const s8 *kfile); keyset_t *keyset_find(sce_buffer_ctxt_t *ctxt); +keyset_t *keyset_bruteforce(sce_buffer_ctxt_t *ctxt); keyset_t *keyset_find_by_name(const s8 *name); -BOOL curves_load(const s8 *cfile); +bool curves_load(const s8 *cfile); curve_t *curve_find(u8 ctype); -BOOL vsh_curves_load(const s8 *cfile); +bool vsh_curves_load(const s8 *cfile); curve_t *vsh_curve_find(u8 ctype); -BOOL klicensee_by_content_id(const s8 *content_id, u8 *klicensee); -BOOL dev_klicensee_by_content_id(const s8 *content_id, u8 *klicensee); +bool klicensee_by_content_id(const s8 *content_id, u8 *klicensee); +bool dev_klicensee_by_content_id(const s8 *content_id, u8 *klicensee); keyset_t *keyset_from_buffer(u8 *keyset); +keyset_t *get_used_keyset(); #endif diff --git a/src/list.cpp b/src/list.cpp index aac05ea..ded4c47 100644 --- a/src/list.cpp +++ b/src/list.cpp @@ -38,7 +38,7 @@ void list_destroy(list_t *l) free(l); } -BOOL list_isempty(list_t *l) +bool list_isempty(list_t *l) { if(l == NULL) return FALSE; @@ -56,7 +56,7 @@ u32 list_count(list_t *l) return l->count; } -BOOL list_push(list_t *l, void *value) +bool list_push(list_t *l, void *value) { if(l == NULL) return FALSE; @@ -96,7 +96,7 @@ void *list_pop(list_t *l) return res; } -BOOL list_add_back(list_t *l, void *value) +bool list_add_back(list_t *l, void *value) { if(l == NULL) return FALSE; @@ -155,7 +155,7 @@ lnode_t *list_get_node(list_t *l, u32 idx) return iter; } -BOOL list_remove_node(list_t *l, lnode_t *node) +bool list_remove_node(list_t *l, lnode_t *node) { if(l == NULL) return FALSE; @@ -188,7 +188,7 @@ BOOL list_remove_node(list_t *l, lnode_t *node) return FALSE; } -BOOL list_remove_value(list_t *l, void *value) +bool list_remove_value(list_t *l, void *value) { if(l == NULL) return FALSE; diff --git a/src/list.h b/src/list.h index a42b081..172261e 100644 --- a/src/list.h +++ b/src/list.h @@ -24,14 +24,14 @@ typedef struct _list list_t *list_create(); void list_destroy(list_t *l); -BOOL list_isempty(list_t *l); +bool list_isempty(list_t *l); u32 list_count(list_t *l); -BOOL list_push(list_t *l, void *value); +bool list_push(list_t *l, void *value); void *list_pop(list_t *l); -BOOL list_add_back(list_t *l, void *value); +bool list_add_back(list_t *l, void *value); void *list_get(list_t *l, u32 idx); lnode_t *list_get_node(list_t *l, u32 idx); -BOOL list_remove_node(list_t *l, lnode_t *node); -BOOL list_remove_value(list_t *l, void *value); +bool list_remove_node(list_t *l, lnode_t *node); +bool list_remove_value(list_t *l, void *value); #endif diff --git a/src/main.cpp b/src/main.cpp index f429155..6d139b1 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -2,6 +2,7 @@ * Copyright (c) 2011-2013 by naehrwert * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -36,20 +37,20 @@ #define ARG_OPT optional_argument /*! Verbose mode. */ -BOOL _verbose = FALSE; +bool _verbose = FALSE; /*! Raw mode. */ -BOOL _raw = FALSE; +bool _raw = FALSE; /*! We got work. */ -static BOOL _got_work = FALSE; +static bool _got_work = FALSE; /*! List keys. */ -static BOOL _list_keys = FALSE; +static bool _list_keys = FALSE; /*! Print infos on file. */ -static BOOL _print_info = FALSE; +static bool _print_info = FALSE; /*! Decrypt file. */ -static BOOL _decrypt_file = FALSE; +static bool _decrypt_file = FALSE; /*! Encrypt file. */ -static BOOL _encrypt_file = FALSE; +static bool _encrypt_file = FALSE; /*! Parameters. */ s8 *_template = NULL; @@ -61,15 +62,13 @@ s8 *_meta_info = NULL; s8 *_keyset = NULL; s8 *_auth_id = NULL; s8 *_vendor_id = NULL; -s8 *_self_type = NULL; +s8 *_program_type = NULL; s8 *_app_version = NULL; s8 *_fw_version = NULL; s8 *_add_shdrs = NULL; s8 *_ctrl_flags = NULL; s8 *_cap_flags = NULL; -#ifdef CONFIG_CUSTOM_INDIV_SEED s8 *_indiv_seed = NULL; -#endif s8 *_license_type = NULL; s8 *_app_type = NULL; s8 *_content_id = NULL; @@ -84,7 +83,7 @@ static s8 *_file_out = NULL; /*! Long option values. */ #define VAL_TEMPLATE 't' -#define VAL_FILE_TYPE '0' +#define VAL_FILE_CATEGORY '0' #define VAL_COMPRESS_DATA '1' #define VAL_SKIP_SECTIONS 's' #define VAL_KEY_REV '2' @@ -92,15 +91,13 @@ static s8 *_file_out = NULL; #define VAL_KEYSET 'K' #define VAL_AUTH_ID '3' #define VAL_VENDOR_ID '4' -#define VAL_SELF_TYPE '5' +#define VAL_PROGRAM_TYPE '5' #define VAL_APP_VERSION 'A' #define VAL_FW_VERSION '6' #define VAL_ADD_SHDRS '7' #define VAL_CTRL_FLAGS '8' #define VAL_CAP_FLAGS '9' -#ifdef CONFIG_CUSTOM_INDIV_SEED #define VAL_INDIV_SEED 'a' -#endif #define VAL_LICENSE_TYPE 'b' #define VAL_APP_TYPE 'c' #define VAL_CONTENT_ID 'f' @@ -118,23 +115,21 @@ static struct option options[] = {"verbose", ARG_NONE, NULL, 'v'}, {"raw", ARG_NONE, NULL, 'r'}, {"template", ARG_REQ, NULL, VAL_TEMPLATE}, - {"sce-type", ARG_REQ, NULL, VAL_FILE_TYPE}, + {"category", ARG_REQ, NULL, VAL_FILE_CATEGORY}, {"compress-data", ARG_REQ, NULL, VAL_COMPRESS_DATA}, {"skip-sections", ARG_REQ, NULL, VAL_SKIP_SECTIONS}, {"key-revision", ARG_REQ, NULL, VAL_KEY_REV}, {"meta-info", ARG_REQ, NULL, VAL_META_INFO}, {"keyset", ARG_REQ, NULL, VAL_KEYSET}, - {"self-auth-id", ARG_REQ, NULL, VAL_AUTH_ID}, - {"self-vendor-id", ARG_REQ, NULL, VAL_VENDOR_ID}, - {"self-type", ARG_REQ, NULL, VAL_SELF_TYPE}, + {"program-auth-id", ARG_REQ, NULL, VAL_AUTH_ID}, + {"program-vendor-id", ARG_REQ, NULL, VAL_VENDOR_ID}, + {"program-type", ARG_REQ, NULL, VAL_PROGRAM_TYPE}, {"self-app-version", ARG_REQ, NULL, VAL_APP_VERSION}, {"self-fw-version", ARG_REQ, NULL, VAL_FW_VERSION}, {"self-add-shdrs", ARG_REQ, NULL, VAL_ADD_SHDRS}, {"self-ctrl-flags", ARG_REQ, NULL, VAL_CTRL_FLAGS}, {"self-cap-flags", ARG_REQ, NULL, VAL_CAP_FLAGS}, -#ifdef CONFIG_CUSTOM_INDIV_SEED {"self-indiv-seed", ARG_REQ, NULL, VAL_INDIV_SEED}, -#endif {"np-license-type", ARG_REQ, NULL, VAL_LICENSE_TYPE}, {"np-app-type", ARG_REQ, NULL, VAL_APP_TYPE}, {"np-content-id", ARG_REQ, NULL, VAL_CONTENT_ID}, @@ -158,41 +153,39 @@ static void print_usage() print_version(); printf("USAGE: scetool [options] command\n"); - printf("COMMANDS Parameters Explanation\n"); - printf(" -h, --help Print this help.\n"); - printf(" -k, --print-keys List keys.\n"); - printf(" -i, --print-infos File-in Print SCE file info.\n"); - printf(" -d, --decrypt File-in File-out Decrypt/dump SCE file.\n"); - printf(" -e, --encrypt File-in File-out Encrypt/create SCE file.\n"); - printf("OPTIONS Possible Values Explanation\n"); - printf(" -v, --verbose Enable verbose output.\n"); - printf(" -r, --raw Enable raw value output.\n"); - printf(" -t, --template File-in Template file (SELF only)\n"); - printf(" -0, --sce-type SELF/RVK/PKG/SPP SCE File Type\n"); - printf(" -1, --compress-data TRUE/FALSE(default) Whether to compress data or not.\n"); - printf(" -s, --skip-sections TRUE(default)/FALSE Whether to skip sections or not.\n"); - printf(" -2, --key-revision e.g. 00,01,...,0A,... Key Revision\n"); - printf(" -m, --meta-info 64 bytes Use provided meta info to decrypt.\n"); - printf(" -K, --keyset 32(Key)16(IV)\n"); - printf(" 40(Pub)21(Priv)1(CT) Override keyset.\n"); - printf(" -3, --self-auth-id e.g. 1010000001000003 Authentication ID\n"); - printf(" -4, --self-vendor-id e.g. 01000002 Vendor ID\n"); - printf(" -5, --self-type LV0/LV1/LV2/APP/ISO/\n"); - printf(" LDR/NPDRM SELF Type\n"); - printf(" -A, --self-app-version e.g. 0001000000000000 Application Version\n"); - printf(" -6, --self-fw-version e.g. 0003004100000000 Firmware Version\n"); - printf(" -7, --self-add-shdrs TRUE(default)/FALSE Whether to add ELF shdrs or not.\n"); - printf(" -8, --self-ctrl-flags 32 bytes Override control flags.\n"); - printf(" -9, --self-cap-flags 32 bytes Override capability flags.\n"); -#ifdef CONFIG_CUSTOM_INDIV_SEED - printf(" -a, --self-indiv-seed 256 bytes Individuals Seed (ISO only)\n"); -#endif - printf(" -b, --np-license-type LOCAL/FREE License Type\n"); - printf(" -c, --np-app-type SPRX/EXEC/USPRX/UEXEC App Type (U* for updates)\n"); - printf(" -f, --np-content-id Content ID\n"); - printf(" -l, --np-klicensee 16 bytes Override klicensee.\n"); - printf(" -g, --np-real-fname e.g. EBOOT.BIN Real Filename\n"); - printf(" -j, --np-add-sig TRUE/FALSE(default) Whether to add a NP sig. or not.\n"); + printf("COMMANDS Parameters Explanation\n"); + printf(" -h, --help Print this help.\n"); + printf(" -k, --print-keys List keys.\n"); + printf(" -i, --print-infos File-in Print SCE file info.\n"); + printf(" -d, --decrypt File-in File-out Decrypt/dump SCE file.\n"); + printf(" -e, --encrypt File-in File-out Encrypt/create SCE file.\n"); + printf("OPTIONS Possible Values Explanation\n"); + printf(" -v, --verbose Enable verbose output.\n"); + printf(" -r, --raw Enable raw value output.\n"); + printf(" -t, --template File-in Template file (SELF only)\n"); + printf(" -0, --category SELF/RVK/PKG/SPP SCE File Type\n"); + printf(" -1, --compress-data TRUE/FALSE(default) Whether to compress data or not.\n"); + printf(" -s, --skip-sections TRUE(default)/FALSE Whether to skip sections or not.\n"); + printf(" -2, --key-revision e.g. 00,01,...,0A,... Key Revision\n"); + printf(" -m, --meta-info 64 bytes Use provided meta info to decrypt.\n"); + printf(" -K, --keyset 32(Key)16(IV)\n"); + printf(" 40(Pub)21(Priv)1(CT) Override keyset.\n"); + printf(" -3, --program-auth-id e.g. 1010000001000003 Authentication ID\n"); + printf(" -4, --program-vendor-id e.g. 01000002 Vendor ID\n"); + printf(" -5, --program-type LV0/LV1/LV2/APP/ISO/\n"); + printf(" LDR/NPDRM Program Type\n"); + printf(" -A, --self-app-version e.g. 0001000000000000 Application Version\n"); + printf(" -6, --self-fw-version e.g. 0003004100000000 Firmware Version\n"); + printf(" -7, --self-add-shdrs TRUE(default)/FALSE Whether to add ELF shdrs or not.\n"); + printf(" -8, --self-ctrl-flags 32 bytes Override control flags.\n"); + printf(" -9, --self-cap-flags 32 bytes Override capability flags.\n"); + printf(" -a, --self-indiv-seed 256 bytes Individuals Seed (ISO only)\n"); + printf(" -b, --np-license-type LOCAL/FREE License Type\n"); + printf(" -c, --np-app-type SPRX/EXEC/USPRX/UEXEC App Type (U* for updates)\n"); + printf(" -f, --np-content-id Content ID\n"); + printf(" -l, --np-klicensee 16 bytes Override klicensee.\n"); + printf(" -g, --np-real-fname e.g. EBOOT.BIN Real Filename\n"); + printf(" -j, --np-add-sig TRUE/FALSE(default) Whether to add a NP sig. or not.\n"); //getchar(); @@ -203,11 +196,7 @@ static void parse_args(int argc, char **argv) { char c; -#ifdef CONFIG_CUSTOM_INDIV_SEED while((c = getopt_long(argc, argv, "hki:d:e:vrt:0:1:s:2:m:K:3:4:5:A:6:7:8:9:a:b:c:f:l:g:j:", options, NULL)) != -1) -#else - while((c = getopt_long(argc, argv, "hki:d:e:vrt:0:1:s:2:m:K:3:4:5:A:6:7:8:9:b:c:f:l:g:j:", options, NULL)) != -1) -#endif { switch(c) { @@ -250,7 +239,7 @@ static void parse_args(int argc, char **argv) case VAL_TEMPLATE: _template = optarg; break; - case VAL_FILE_TYPE: + case VAL_FILE_CATEGORY: _file_type = optarg; break; case VAL_COMPRESS_DATA: @@ -274,8 +263,8 @@ static void parse_args(int argc, char **argv) case VAL_VENDOR_ID: _vendor_id = optarg; break; - case VAL_SELF_TYPE: - _self_type = optarg; + case VAL_PROGRAM_TYPE: + _program_type = optarg; break; case VAL_APP_VERSION: _app_version = optarg; @@ -292,11 +281,9 @@ static void parse_args(int argc, char **argv) case VAL_CAP_FLAGS: _cap_flags = optarg; break; -#ifdef CONFIG_CUSTOM_INDIV_SEED case VAL_INDIV_SEED: _indiv_seed = optarg; break; -#endif case VAL_LICENSE_TYPE: _license_type = optarg; break; @@ -394,8 +381,33 @@ int main(int argc, char **argv) else printf("[*] Warning: Could not load keys.\n"); } + + //Load internal keysets. + if(ps3 != NULL) + { + sprintf(path, "%s/%s", ps3, CONFIG_INTERNAL_KEYS_FILE); + if(access(path, 0) != 0) + sprintf(path, "%s/%s", CONFIG_KEYS_PATH, CONFIG_INTERNAL_KEYS_FILE); + if(access(path, 0) != 0) + sprintf(path, "%s/%s/%s", ps3, CONFIG_KEYS_PATH, CONFIG_INTERNAL_KEYS_FILE); + } + else + sprintf(path, "%s/%s", CONFIG_KEYS_PATH, CONFIG_INTERNAL_KEYS_FILE); + if(internal_keys_load(path) == TRUE) + _LOG_VERBOSE("Loaded internal keysets.\n"); + else + { + if(_list_keys == TRUE) + { + printf("[*] Error: Could not load internal keys.\n"); + return 0; + } + else + printf("[*] Warning: Could not load internal keys.\n"); + } + - //Load curves. + //Load loader curves. if(ps3 != NULL) { sprintf(path, "%s/%s", ps3, CONFIG_CURVES_FILE); @@ -411,7 +423,7 @@ int main(int argc, char **argv) else printf("[*] Warning: Could not load loader curves.\n"); - //Load curves. + //Load vsh curves. if(ps3 != NULL) { sprintf(path, "%s/%s", ps3, CONFIG_VSH_CURVES_FILE); @@ -442,6 +454,8 @@ int main(int argc, char **argv) { printf("[*] Loaded keysets:\n"); _print_key_list(stdout); + printf("[*] Loaded internal keysets:\n"); + _print_internal_key_list(stdout); } else if(_print_info) frontend_print_infos(_file_in); diff --git a/src/np.cpp b/src/np.cpp index 1b33227..3b733f9 100644 --- a/src/np.cpp +++ b/src/np.cpp @@ -3,6 +3,7 @@ * Copyright (c) 2012 by flatz * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include @@ -46,7 +47,7 @@ void np_set_klicensee(u8 *klicensee) _klicensee_key = klicensee; } -BOOL np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt) +bool np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt) { aes_context aes_ctxt; ci_data_npdrm_t *np; @@ -109,7 +110,7 @@ BOOL np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt) return TRUE; } -BOOL np_encrypt_npdrm(sce_buffer_ctxt_t *ctxt) +bool np_encrypt_npdrm(sce_buffer_ctxt_t *ctxt) { aes_context aes_ctxt; keyset_t *ks_np_klic_free, *ks_klic_key; @@ -151,7 +152,7 @@ BOOL np_encrypt_npdrm(sce_buffer_ctxt_t *ctxt) return TRUE; } -BOOL np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp) +bool np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp) { u32 i, len; u8 *cid_fname, ci_key[0x10]; @@ -187,12 +188,7 @@ BOOL np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp) cinp->license_type = _ES32(npconf->license_type); cinp->app_type = _ES32(npconf->app_type); memcpy(cinp->content_id, npconf->content_id, 0x30); - #ifdef CONFIG_PRIVATE_BUILD - _fill_rand_bytes(cinp->rndpad, 0x10); - #else - //Better than boring random bytes! - memcpy(cinp->rndpad, CONFIG_NPDRM_WATERMARK, 0x10); - #endif + _fill_rand_bytes(cinp->rndpad, 0x10); cinp->limited_time_start = _ES64(0); cinp->limited_time_end = _ES64(0); @@ -215,7 +211,7 @@ BOOL np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp) //TODO: The fwrite/fread error checking was broken. //Maybe the MS runtime is returning the number of bytes written instead of the element count? -BOOL np_sign_file(s8 *fname) +bool np_sign_file(s8 *fname) { u8 padding_data[0x10] = { diff --git a/src/np.h b/src/np.h index eff5309..1b47851 100644 --- a/src/np.h +++ b/src/np.h @@ -28,15 +28,15 @@ typedef struct _npdrm_config void np_set_klicensee(u8 *klicensee); /*! Remove NPDRM layer. */ -BOOL np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt); +bool np_decrypt_npdrm(sce_buffer_ctxt_t *ctxt); /*! Add NPDRM layer. */ -BOOL np_encrypt_npdrm(sce_buffer_ctxt_t *ctxt); +bool np_encrypt_npdrm(sce_buffer_ctxt_t *ctxt); /*! Create NPDRM control info. */ -BOOL np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp); +bool np_create_ci(npdrm_config_t *npconf, ci_data_npdrm_t *cinp); /*! Add NP signature to file. */ -BOOL np_sign_file(s8 *fname); +bool np_sign_file(s8 *fname); #endif diff --git a/src/rvk.cpp b/src/rvk.cpp index e0516ec..8119df0 100644 --- a/src/rvk.cpp +++ b/src/rvk.cpp @@ -28,7 +28,7 @@ static void _print_rvk_header(FILE *fp, rvk_header_t *h) /* typedef struct _prg_rvk_entry { - u32 self_type; //3, 4 + u32 program_type; //3, 4 u32 unk_1; //1, 3 union { @@ -65,11 +65,11 @@ static void _print_prg_rvk_entry(FILE *fp, prg_rvk_entry_t *e) { const s8 *name; - name = _get_name(_self_types, e->self_type); + name = _get_name(_program_types, e->program_type); if(name != NULL) fprintf(fp, " %-19s ", name); else - fprintf(fp, " 0x%08X ", e->self_type); + fprintf(fp, " 0x%08X ", e->program_type); name = _get_name(_check_type_values, e->check_type); if(name != NULL) diff --git a/src/rvk.h b/src/rvk.h index 52ce830..be035ba 100644 --- a/src/rvk.h +++ b/src/rvk.h @@ -58,7 +58,7 @@ static inline void _es_rvk_header(rvk_header_t *h) /*! Program revoke list entry. */ typedef struct _prg_rvk_entry { - u32 self_type; //3, 4 + u32 program_type; //3, 4 u32 check_type; u64 version; union @@ -71,7 +71,7 @@ typedef struct _prg_rvk_entry static inline void _es_prg_rvk_entry(prg_rvk_entry_t *e) { - e->self_type = _ES32(e->self_type); + e->program_type = _ES32(e->program_type); e->check_type = _ES32(e->check_type); e->version = _ES64(e->version); e->auth_id = _ES64(e->auth_id); diff --git a/src/sce.cpp b/src/sce.cpp index 34c0be7..b5d6cd9 100644 --- a/src/sce.cpp +++ b/src/sce.cpp @@ -3,6 +3,7 @@ * Copyright (c) 2011-2012 by Youness Alaoui * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -23,43 +24,58 @@ #include "zlib.h" #include "np.h" -void _print_sce_header(FILE *fp, sce_header_t *h) +void _print_cert_file_header(FILE *fp, cert_file_header_t *h) { const s8 *name; const s8 *key_revision; - fprintf(fp, "[*] SCE Header:\n"); - fprintf(fp, " Magic 0x%08X [%s]\n", _ES32(h->magic), (_ES32(h->magic) == SCE_HEADER_MAGIC ? "OK" : "ERROR")); - fprintf(fp, " Version 0x%08X\n", _ES32(h->version)); + fprintf(fp, "[*] Certified File Header:\n"); + fprintf(fp, " Magic 0x%08X [%s]\n", _ES32(h->magic), (_ES32(h->magic) == CF_MAGIC ? "OK" : "ERROR")); + fprintf(fp, " Version 0x%08X\n", _ES32(h->version)); if(_ES16(h->key_revision) == KEY_REVISION_DEBUG) - fprintf(fp, " Key Revision [DEBUG]\n"); + fprintf(fp, " Key Revision [DEBUG]\n"); else - fprintf(fp, " Key Revision 0x%04X\n", _ES16(h->key_revision)); + fprintf(fp, " Key Revision 0x%04X\n", _ES16(h->key_revision)); - name = _get_name(_sce_header_types, _ES16(h->header_type)); + name = _get_name(_cert_file_categories, _ES16(h->category)); if(name != NULL) - fprintf(fp, " Header Type [%s]\n", name); + { + fprintf(fp, " Category "); + _PRINT_RAW(fp, "0x%04X ", _ES16(h->category)); + fprintf(fp, "[%s]\n", name); + } else - fprintf(fp, " Header Type 0x%04X\n", _ES16(h->header_type)); + fprintf(fp, " Category 0x%04X\n", _ES16(h->category)); - fprintf(fp, " Metadata Offset 0x%08X\n", _ES32(h->metadata_offset)); - fprintf(fp, " Header Length 0x%016llX\n", _ES64(h->header_len)); - fprintf(fp, " Data Length 0x%016llX\n", _ES64(h->data_len)); + fprintf(fp, " Ext Header Size 0x%08X\n", _ES32(h->ext_header_size)); + fprintf(fp, " File Offset 0x%016llX\n", _ES64(h->file_offset)); + fprintf(fp, " File Size 0x%016llX\n", _ES64(h->file_size)); } void _print_metadata_info(FILE *fp, metadata_info_t *mi) { - fprintf(fp, "[*] Metadata Info:\n"); + fprintf(fp, "[*] Encryption Root Header:\n"); _hexdump(fp, " Key", 0, mi->key, METADATA_INFO_KEY_LEN, FALSE); _hexdump(fp, " IV ", 0, mi->iv, METADATA_INFO_IV_LEN, FALSE); } void _print_metadata_header(FILE *fp, metadata_header_t *mh) { + const s8 *sig_algo; + sig_algo = _get_name(_sig_algorithms, _ES32(mh->sig_algorithm)); + + fprintf(fp, "[*] Metadata Header:\n"); fprintf(fp, " Signature Input Length 0x%016llX\n", _ES64(mh->sig_input_length)); - fprintf(fp, " unknown_0 0x%08X\n", _ES32(mh->unknown_0)); + if(sig_algo != NULL) + { + fprintf(fp, " Signature Algorithm "); + _PRINT_RAW(fp, "0x%08X ", _ES32(mh->sig_algorithm)); + fprintf(fp, "[%s]\n", sig_algo); + } + else + fprintf(fp, " Signature Algorithm 0x%08X\n", _ES32(mh->sig_algorithm)); fprintf(fp, " Section Count 0x%08X\n", _ES32(mh->section_count)); fprintf(fp, " Key Count 0x%08X\n", _ES32(mh->key_count)); fprintf(fp, " Optional Header Size 0x%08X\n", _ES32(mh->opt_header_size)); @@ -127,29 +143,28 @@ void _print_sce_signature_status(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset) //Check if a keyset is provided. if(keyset == NULL) { - //Try to find keyset. - ks = keyset_find(ctxt); + //Get previously used keyset + ks = get_used_keyset(); } else { //Use the provided keyset. ks = keyset_from_buffer(keyset); } + //Generate header hash. sha1(ctxt->scebuffer, _ES64(ctxt->metah->sig_input_length), hash); - _hexdump(fp, " E", 0, hash, 0x14, FALSE); - + _hexdump(fp, " E", 0, hash, 0x14, FALSE); + ecdsa_set_curve(ks->ctype); ecdsa_set_pub(ks->pub); - - #ifdef CONFIG_PRIVATE_BUILD + //validate private key and calculate M ec_priv_to_pub(ks->priv, Q); get_m(ctxt->sig->r, ctxt->sig->s, hash, ks->priv, M); if (memcmp(ks->pub, Q, sizeof(Q)) == 0) _hexdump (fp, " M", 0, M, 0x14, FALSE); - #endif - + //Validate the signature. memset(zero_buf, 0, sizeof(zero_buf)); if ((memcmp(ctxt->sig->r, zero_buf, sizeof(zero_buf)) == 0) || (memcmp(ctxt->sig->s, zero_buf, sizeof(zero_buf)) == 0)) @@ -170,9 +185,9 @@ static sce_buffer_ctxt_t *_sce_create_ctxt() res->scebuffer = NULL; res->mdec = TRUE; - //Allocate SCE header. - res->sceh = (sce_header_t *)malloc(sizeof(sce_header_t)); - memset(res->sceh, 0, sizeof(sce_header_t)); + //Allocate Cert file header. + res->cfh = (cert_file_header_t *)malloc(sizeof(cert_file_header_t)); + memset(res->cfh, 0, sizeof(cert_file_header_t)); //Allocate metadata info (with random key/iv). res->metai = (metadata_info_t *)malloc(sizeof(metadata_info_t)); @@ -203,22 +218,27 @@ sce_buffer_ctxt_t *sce_create_ctxt_from_buffer(u8 *scebuffer) res->scebuffer = scebuffer; res->mdec = FALSE; - //Set pointer to SCE header. - res->sceh = (sce_header_t *)scebuffer; + //Set pointer to Cert file header. + res->cfh = (cert_file_header_t *)scebuffer; //Set pointers to file type specific headers. - switch(_ES16(res->sceh->header_type)) + switch(_ES16(res->cfh->category)) { - case SCE_HEADER_TYPE_SELF: + case CF_CATEGORY_SELF: { //SELF header. - res->self.selfh = (self_header_t *)(res->scebuffer + sizeof(sce_header_t)); + res->self.selfh = (self_header_t *)(res->scebuffer + sizeof(cert_file_header_t)); - //Application info. + //Program info. res->self.ai = (app_info_t *)(res->scebuffer + _ES64(res->self.selfh->app_info_offset)); //Section infos. - res->self.si = (section_info_t *)(res->scebuffer + _ES64(res->self.selfh->section_info_offset)); + if (_ES64(res->self.selfh->section_info_offset) != NULL) + { + res->self.si = (section_info_t *)(res->scebuffer + _ES64(res->self.selfh->section_info_offset)); + } + else + res->self.si = 0; //SCE version. if(_ES64(res->self.selfh->sce_version_offset) != NULL) @@ -229,31 +249,34 @@ sce_buffer_ctxt_t *sce_create_ctxt_from_buffer(u8 *scebuffer) res->self.sv = 0; //Get pointers to all control infos. - u32 len = (u32)(_ES64(res->self.selfh->control_info_size)); - if(len > 0) + if ((_ES64(res->self.selfh->control_info_offset)) != 0) { - u8 *ptr = res->scebuffer + _ES64(res->self.selfh->control_info_offset); - res->self.cis = list_create(); - - while(len > 0) + u32 len = (u32)(_ES64(res->self.selfh->control_info_size)); + if(len > 0) { - control_info_t *tci = (control_info_t *)ptr; - ptr += _ES32(tci->size); - len -= _ES32(tci->size); - list_add_back(res->self.cis, tci); + u8 *ptr = res->scebuffer + _ES64(res->self.selfh->control_info_offset); + res->self.cis = list_create(); + + while(len > 0) + { + control_info_t *tci = (control_info_t *)ptr; + ptr += _ES32(tci->size); + len -= _ES32(tci->size); + list_add_back(res->self.cis, tci); + } } } else res->self.cis = NULL; } break; - case SCE_HEADER_TYPE_RVK: + case CF_CATEGORY_RVK: //TODO break; - case SCE_HEADER_TYPE_PKG: + case CF_CATEGORY_PKG: //TODO break; - case SCE_HEADER_TYPE_SPP: + case CF_CATEGORY_SPP: //TODO break; default: @@ -263,7 +286,7 @@ sce_buffer_ctxt_t *sce_create_ctxt_from_buffer(u8 *scebuffer) } //Set pointers to metadata headers. - res->metai = (metadata_info_t *)(scebuffer + sizeof(sce_header_t) + _ES32(res->sceh->metadata_offset)); + res->metai = (metadata_info_t *)(scebuffer + sizeof(cert_file_header_t) + _ES32(res->cfh->ext_header_size)); res->metah = (metadata_header_t *)((u8 *)res->metai + sizeof(metadata_info_t)); res->metash = (metadata_section_header_t *)((u8 *)res->metah + sizeof(metadata_header_t)); @@ -277,15 +300,15 @@ sce_buffer_ctxt_t *sce_create_ctxt_build_self(u8 *elf, u32 elf_len) if((res = _sce_create_ctxt()) == NULL) return NULL; - res->sceh->magic = _ES32(SCE_HEADER_MAGIC); - res->sceh->version = _ES32(SCE_HEADER_VERSION_2); - res->sceh->header_type = _ES16(SCE_HEADER_TYPE_SELF); + res->cfh->magic = _ES32(CF_MAGIC); + res->cfh->version = _ES32(CF_VERSION_2); + res->cfh->category = _ES16(CF_CATEGORY_SELF); //Allocate SELF header. res->self.selfh = (self_header_t *)malloc(sizeof(self_header_t)); memset(res->self.selfh, 0, sizeof(self_header_t)); res->self.selfh->header_type = _ES64(SUB_HEADER_TYPE_SELF); - //Allocate application info. + //Allocate program info. res->self.ai = (app_info_t *)malloc(sizeof(app_info_t)); memset(res->self.ai, 0, sizeof(app_info_t)); //SCE version. @@ -308,7 +331,7 @@ sce_buffer_ctxt_t *sce_create_ctxt_build_self(u8 *elf, u32 elf_len) return res; } -void sce_add_data_section(sce_buffer_ctxt_t *ctxt, void *buffer, u32 size, BOOL may_compr) +void sce_add_data_section(sce_buffer_ctxt_t *ctxt, void *buffer, u32 size, bool may_compr) { sce_section_ctxt_t *sctxt = (sce_section_ctxt_t *)malloc(sizeof(sce_section_ctxt_t)); sctxt->buffer = buffer; @@ -317,7 +340,7 @@ void sce_add_data_section(sce_buffer_ctxt_t *ctxt, void *buffer, u32 size, BOOL list_add_back(ctxt->secs, sctxt); } -void sce_set_metash(sce_buffer_ctxt_t *ctxt, u32 type, BOOL encrypted, u32 idx) +void sce_set_metash(sce_buffer_ctxt_t *ctxt, u32 type, bool encrypted, u32 idx) { ctxt->metash[idx].type = _ES32(type); ctxt->metash[idx].index = _ES32(_ES32(type) == METADATA_SECTION_TYPE_PHDR ? idx : _ES32(type) == METADATA_SECTION_TYPE_SHDR ? idx + 1 : idx); @@ -351,7 +374,7 @@ void sce_compress_data(sce_buffer_ctxt_t *ctxt) sec->size = size_comp; //Set compression in section info. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF && i < ctxt->makeself->si_sec_cnt) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF && i < ctxt->makeself->si_sec_cnt) { ctxt->self.si[i].compressed = SECTION_INFO_COMPRESSED; //Update size too. @@ -400,7 +423,7 @@ void _sce_fixup_ctxt(sce_buffer_ctxt_t *ctxt) u32 i = 0, base_off, last_off; //Set section info data. - base_off = _ES64(ctxt->sceh->header_len); + base_off = _ES64(ctxt->cfh->file_offset); LIST_FOREACH(iter, ctxt->secs) { //Save last offset. @@ -411,7 +434,7 @@ void _sce_fixup_ctxt(sce_buffer_ctxt_t *ctxt) sec->offset = base_off; //Section infos for SELF (that are present as data sections). - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF && i < ctxt->makeself->si_sec_cnt) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF && i < ctxt->makeself->si_sec_cnt) //{ ctxt->self.si[i].offset = base_off; // ctxt->self.si[i].size = sec->size; @@ -423,25 +446,25 @@ void _sce_fixup_ctxt(sce_buffer_ctxt_t *ctxt) //Update offset and data length. base_off += sec->size; - ctxt->sceh->data_len = _ES64(base_off - _ES64(ctxt->sceh->header_len)); + ctxt->cfh->file_size = _ES64(base_off - _ES64(ctxt->cfh->file_offset)); base_off = ALIGN(base_off, SCE_ALIGN); i++; } - //Set metadata offset (counted from after SCE header). - ctxt->sceh->metadata_offset = _ES32(ctxt->off_metai - sizeof(sce_header_t)); + //Set metadata offset (counted from after Cert file header). + ctxt->cfh->ext_header_size = _ES32(ctxt->off_metai - sizeof(cert_file_header_t)); //Set metadata header values. ctxt->metah->sig_input_length = _ES64(ctxt->off_sig); - ctxt->metah->unknown_0 = _ES32(1); + ctxt->metah->sig_algorithm = _ES32(SIGNATURE_ALGORITHM_ECDSA); ctxt->metah->opt_header_size = _ES32(_sce_get_oh_len(ctxt)); ctxt->metah->unknown_1 = _ES32(0); ctxt->metah->unknown_2 = _ES32(0); - switch(_ES16(ctxt->sceh->header_type)) + switch(_ES16(ctxt->cfh->category)) { - case SCE_HEADER_TYPE_SELF: + case CF_CATEGORY_SELF: { //Set header offsets. ctxt->self.selfh->app_info_offset = _ES64(ctxt->off_self.off_ai); @@ -459,13 +482,13 @@ void _sce_fixup_ctxt(sce_buffer_ctxt_t *ctxt) ctxt->self.selfh->shdr_offset = _ES64(0); } break; - case SCE_HEADER_TYPE_RVK: + case CF_CATEGORY_RVK: //TODO break; - case SCE_HEADER_TYPE_PKG: + case CF_CATEGORY_PKG: //TODO break; - case SCE_HEADER_TYPE_SPP: + case CF_CATEGORY_SPP: //TODO break; default: @@ -504,24 +527,6 @@ void _sce_fixup_keys(sce_buffer_ctxt_t *ctxt) //Allocate and fill keys array. ctxt->keys = (u8 *)malloc(sizeof(u8) * ctxt->keys_len); _fill_rand_bytes(ctxt->keys, ctxt->keys_len); - -#ifndef CONFIG_PRIVATE_BUILD - time_t rawtime; - struct tm *ti; - s8 buf[16+1]; - - time(&rawtime); - ti = localtime(&rawtime); - sprintf(buf, "%02d%02d%02d::%02d%02d%04d", - ti->tm_hour, ti->tm_min, ti->tm_sec, - ti->tm_mday, ti->tm_mon, ti->tm_year+1900); - - memcpy(ctxt->keys + 0x20, "SURPRIZE :D "/**/, 12); - memcpy(ctxt->keys + 0x30, "IM IN UR KEYZ !!", 16); - u8 foo[16] = {0x09, 0xB8, 0xBE, 0xAE, 0x83, 0xC0, 0x17, 0xA6, 0x3B, 0x11, 0xB0, 0x50, 0xC4, 0xCE, 0xED, 0xF9}; - memcpy(ctxt->keys + 0x40, foo, 16); - memcpy(ctxt->keys + 0x50, buf, 16); -#endif } /*! Increase offset and align it. */ @@ -536,16 +541,16 @@ void sce_layout_ctxt(sce_buffer_ctxt_t *ctxt) { u32 coff = 0; - //SCE header. - ctxt->off_sceh = _INC_OFF_TYPE(coff, sce_header_t); + //Cert file header. + ctxt->off_cfh = _INC_OFF_TYPE(coff, cert_file_header_t); - switch(_ES16(ctxt->sceh->header_type)) + switch(_ES16(ctxt->cfh->category)) { - case SCE_HEADER_TYPE_SELF: + case CF_CATEGORY_SELF: { //SELF header. ctxt->off_self.off_selfh = _INC_OFF_TYPE(coff, self_header_t); - //Application info. + //Program info. ctxt->off_self.off_ai = _INC_OFF_TYPE(coff, app_info_t); //ELF header. ctxt->off_self.off_ehdr = _INC_OFF_SIZE(coff, ctxt->makeself->ehsize); @@ -559,13 +564,13 @@ void sce_layout_ctxt(sce_buffer_ctxt_t *ctxt) ctxt->off_self.off_cis = _INC_OFF_SIZE(coff, _sce_get_ci_len(ctxt)); } break; - case SCE_HEADER_TYPE_RVK: + case CF_CATEGORY_RVK: //TODO break; - case SCE_HEADER_TYPE_PKG: + case CF_CATEGORY_PKG: //TODO break; - case SCE_HEADER_TYPE_SPP: + case CF_CATEGORY_SPP: //TODO break; default: @@ -584,7 +589,7 @@ void sce_layout_ctxt(sce_buffer_ctxt_t *ctxt) ctxt->off_keys = _INC_OFF_SIZE(coff, ctxt->keys_len); //SELF only headers. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) { //Optional headers. ctxt->off_self.off_ohs = _INC_OFF_SIZE(coff, _sce_get_oh_len(ctxt)); @@ -598,7 +603,7 @@ void sce_layout_ctxt(sce_buffer_ctxt_t *ctxt) coff = ALIGN(coff, HEADER_ALIGN); //Set header length. - ctxt->sceh->header_len = _ES64(coff); + ctxt->cfh->file_offset = _ES64(coff); //Set missing values, etc. _sce_fixup_ctxt(ctxt); @@ -609,20 +614,20 @@ static void _sce_build_header(sce_buffer_ctxt_t *ctxt) u32 i; //Allocate header buffer. - ctxt->scebuffer = (u8*)malloc(sizeof(u8) * _ES64(ctxt->sceh->header_len)); - memset(ctxt->scebuffer, 0, sizeof(u8) * _ES64(ctxt->sceh->header_len)); + ctxt->scebuffer = (u8*)malloc(sizeof(u8) * _ES64(ctxt->cfh->file_offset)); + memset(ctxt->scebuffer, 0, sizeof(u8) * _ES64(ctxt->cfh->file_offset)); - //SCE header. - memcpy((sce_header_t *)(ctxt->scebuffer + ctxt->off_sceh), ctxt->sceh, sizeof(sce_header_t)); + //Cert file header. + memcpy((cert_file_header_t *)(ctxt->scebuffer + ctxt->off_cfh), ctxt->cfh, sizeof(cert_file_header_t)); - //File type dependent headers. - switch(_ES16(ctxt->sceh->header_type)) + //File category dependent headers. + switch(_ES16(ctxt->cfh->category)) { - case SCE_HEADER_TYPE_SELF: + case CF_CATEGORY_SELF: { //SELF header. memcpy((self_header_t *)(ctxt->scebuffer + ctxt->off_self.off_selfh), ctxt->self.selfh, sizeof(self_header_t)); - //Application info. + //Program info. memcpy((app_info_t *)(ctxt->scebuffer + ctxt->off_self.off_ai), ctxt->self.ai, sizeof(app_info_t)); //ELF header. memcpy(ctxt->scebuffer + ctxt->off_self.off_ehdr, ctxt->makeself->ehdr, ctxt->makeself->ehsize); @@ -652,13 +657,13 @@ static void _sce_build_header(sce_buffer_ctxt_t *ctxt) } } break; - case SCE_HEADER_TYPE_RVK: + case CF_CATEGORY_RVK: //TODO break; - case SCE_HEADER_TYPE_PKG: + case CF_CATEGORY_PKG: //TODO break; - case SCE_HEADER_TYPE_SPP: + case CF_CATEGORY_SPP: //TODO break; default: @@ -678,7 +683,7 @@ static void _sce_build_header(sce_buffer_ctxt_t *ctxt) //memcpy(ctxt->scebuffer + ctxt->off_keys, ctxt->keys, ctxt->keys_len); //SELF only headers. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) { //Optional headers. u32 oh_base = ctxt->off_self.off_ohs; @@ -696,7 +701,7 @@ static void _sce_build_header(sce_buffer_ctxt_t *ctxt) } } -static BOOL _sce_sign_header(sce_buffer_ctxt_t *ctxt, keyset_t *ks) +static bool _sce_sign_header(sce_buffer_ctxt_t *ctxt, keyset_t *ks) { u8 hash[0x14]; @@ -735,7 +740,7 @@ static void _sce_calculate_hashes(sce_buffer_ctxt_t *ctxt) } } -static BOOL _sce_encrypt_header(sce_buffer_ctxt_t *ctxt, u8 *keyset) +static bool _sce_encrypt_header(sce_buffer_ctxt_t *ctxt, u8 *keyset) { u8 *ptr; size_t nc_off; @@ -771,7 +776,7 @@ static BOOL _sce_encrypt_header(sce_buffer_ctxt_t *ctxt, u8 *keyset) aes_setkey_enc(&aes_ctxt, ctxt->metai->key, METADATA_INFO_KEYBITS); memcpy(iv, ctxt->metai->iv, 0x10); aes_crypt_ctr(&aes_ctxt, - _ES64(ctxt->sceh->header_len) - (sizeof(sce_header_t) + _ES32(ctxt->sceh->metadata_offset) + sizeof(metadata_info_t)), + _ES64(ctxt->cfh->file_offset) - (sizeof(cert_file_header_t) + _ES32(ctxt->cfh->ext_header_size) + sizeof(metadata_info_t)), &nc_off, iv, sblk, ptr, ptr); //Encrypt metadata info. @@ -780,7 +785,7 @@ static BOOL _sce_encrypt_header(sce_buffer_ctxt_t *ctxt, u8 *keyset) aes_crypt_cbc(&aes_ctxt, AES_ENCRYPT, sizeof(metadata_info_t), ks->riv, ptr, ptr); //Add NPDRM layer. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF && _ES32(ctxt->self.ai->self_type) == SELF_TYPE_NPDRM) + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF && _ES32(ctxt->self.ai->program_type) == PROGRAM_TYPE_NPDRM) if(np_encrypt_npdrm(ctxt) == FALSE) return FALSE; @@ -811,7 +816,7 @@ static void _sce_encrypt_data(sce_buffer_ctxt_t *ctxt) } } -BOOL sce_encrypt_ctxt(sce_buffer_ctxt_t *ctxt, u8 *keyset) +bool sce_encrypt_ctxt(sce_buffer_ctxt_t *ctxt, u8 *keyset) { //Build SCE file header. _sce_build_header(ctxt); @@ -826,7 +831,7 @@ BOOL sce_encrypt_ctxt(sce_buffer_ctxt_t *ctxt, u8 *keyset) return TRUE; } -BOOL sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname) +bool sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname) { FILE *fp; @@ -834,7 +839,7 @@ BOOL sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname) return FALSE; //Write SCE file header. - fwrite(ctxt->scebuffer, sizeof(u8), _ES64(ctxt->sceh->header_len), fp); + fwrite(ctxt->scebuffer, sizeof(u8), _ES64(ctxt->cfh->file_offset), fp); //Write SCE file sections. LIST_FOREACH(iter, ctxt->secs) @@ -848,8 +853,45 @@ BOOL sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname) return TRUE; } +//refactoring needed +static bool check_for_old_algorithm(sce_buffer_ctxt_t *ctxt, keyset_t *ks) +{ + u8 *test_buf = (u8 *)malloc(sizeof(u8) * 0x50); + u8 *test_buf2 = (u8 *)malloc(sizeof(u8) * 0x50); + u8 *iv = (u8 *)malloc(sizeof(u8) * 0x10); + u8 *sblk = (u8 *)malloc(sizeof(u8) * 0x10); + u8 *ctr_iv = (u8 *)malloc(sizeof(u8) * 0x10); + aes_context aes_ctxt; + size_t nc_off; + u64 sig_input_length; + u32 sig_algo, section_count; -BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) + memcpy(test_buf, ctxt->metai, 0x50); + + memcpy(test_buf2, test_buf, 0x50); + nc_off = 0; + + memcpy(test_buf2, test_buf, 0x50); + memcpy(iv, ks->riv, 0x10); + aes_setkey_enc(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + aes_crypt_ctr(&aes_ctxt, 0x40, &nc_off, iv, sblk, test_buf2, test_buf2); + + nc_off = 0; + memcpy (ctr_iv, (test_buf2 + 0x20) ,0x10); + aes_setkey_enc(&aes_ctxt, test_buf2, METADATA_INFO_KEYBITS); + aes_crypt_ctr(&aes_ctxt, 0x10, &nc_off, ctr_iv, sblk, (test_buf2 + 0x40), (test_buf2 + 0x40)); + + sig_input_length = _ES64(*(u64*)&test_buf2[0x40]); + sig_algo = _ES32(*(u32*)&test_buf2[0x48]); + section_count = _ES32(*(u32*)&test_buf2[0x4C]); + + if((sig_input_length < _ES64(ctxt->cfh->file_offset)) && sig_algo == 1 && section_count < 0xFF) + return true; + + return false; +} +//refactoring needed +bool sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) { u32 i; size_t nc_off; @@ -860,11 +902,16 @@ BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) //Check if provided metadata info should be used. if(metadata_info == NULL) { + //Remove NPDRM layer. + if(_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF && _ES32(ctxt->self.ai->program_type) == PROGRAM_TYPE_NPDRM) + if(np_decrypt_npdrm(ctxt) == FALSE) + return FALSE; + //Check if a keyset is provided. if(keyset == NULL) { //Try to find keyset. - if((ks = keyset_find(ctxt)) == NULL) + if((ks = keyset_bruteforce(ctxt)) == NULL) return FALSE; _LOG_VERBOSE("Using keyset [%s 0x%04X %s]\n", ks->name, ks->key_revision, sce_version_to_str(ks->version)); @@ -875,15 +922,21 @@ BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) ks = keyset_from_buffer(keyset); } - //Remove NPDRM layer. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF && _ES32(ctxt->self.ai->self_type) == SELF_TYPE_NPDRM) - if(np_decrypt_npdrm(ctxt) == FALSE) - return FALSE; - //Decrypt metadata info. - aes_setkey_dec(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + + nc_off = 0; + memcpy(iv, ks->riv, 0x10); //!!! - aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, sizeof(metadata_info_t), iv, (u8 *)ctxt->metai, (u8 *)ctxt->metai); + if (check_for_old_algorithm(ctxt, ks) == false) + { + aes_setkey_dec(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + aes_crypt_cbc(&aes_ctxt, AES_DECRYPT, sizeof(metadata_info_t), iv, (u8 *)ctxt->metai, (u8 *)ctxt->metai); + } + else + { + aes_setkey_enc(&aes_ctxt, ks->erk, KEYBITS(ks->erklen)); + aes_crypt_ctr(&aes_ctxt, sizeof(metadata_info_t), &nc_off, iv, sblk, (u8 *)ctxt->metai, (u8 *)ctxt->metai); + } } else { @@ -896,23 +949,23 @@ BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) memcpy (ctr_iv, ctxt->metai->iv ,0x10); aes_setkey_enc(&aes_ctxt, ctxt->metai->key, METADATA_INFO_KEYBITS); aes_crypt_ctr(&aes_ctxt, - _ES64(ctxt->sceh->header_len) - (sizeof(sce_header_t) + _ES32(ctxt->sceh->metadata_offset) + sizeof(metadata_info_t)), + _ES64(ctxt->cfh->file_offset) - (sizeof(cert_file_header_t) + _ES32(ctxt->cfh->ext_header_size) + sizeof(metadata_info_t)), &nc_off, ctr_iv, sblk, (u8 *)ctxt->metah, (u8 *)ctxt->metah); //Check if the metadata was decrypted properly. - if (_ES64(ctxt->metah->sig_input_length) > _ES64(ctxt->sceh->header_len)) + if (_ES64(ctxt->metah->sig_input_length) > _ES64(ctxt->cfh->file_offset)) return FALSE; //Metadata decrypted. ctxt->mdec = TRUE; - + //Set start of SCE file keys. ctxt->keys = (u8 *)ctxt->metash + sizeof(metadata_section_header_t) * _ES32(ctxt->metah->section_count); ctxt->keys_len = _ES32(ctxt->metah->key_count) * 0x10; //Set SELF only headers. - if(_ES16(ctxt->sceh->header_type) == SCE_HEADER_TYPE_SELF) - { + if((_ES16(ctxt->cfh->category) == CF_CATEGORY_SELF) && (_ES64(ctxt->metah->opt_header_size) > 0)) + { //Get pointers to all optional headers. ctxt->self.ohs = list_create(); opt_header_t *oh = (opt_header_t *)(ctxt->keys + _ES32(ctxt->metah->key_count) * 0x10); @@ -932,7 +985,7 @@ BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset) return TRUE; } -BOOL sce_decrypt_data(sce_buffer_ctxt_t *ctxt) +bool sce_decrypt_data(sce_buffer_ctxt_t *ctxt) { u32 i; aes_context aes_ctxt; @@ -962,13 +1015,16 @@ BOOL sce_decrypt_data(sce_buffer_ctxt_t *ctxt) return TRUE; } +void cf_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) +{ + //Print Cert file header. + _print_cert_file_header(fp, ctxt->cfh); +} + void sce_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset) { u32 i; - //Print SCE header. - _print_sce_header(fp, ctxt->sceh); - //Check if the metadata was decrypted. if(ctxt->mdec == FALSE) return; @@ -984,11 +1040,11 @@ void sce_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset) //Print keys. _print_sce_file_keys(fp, ctxt); - - //Print signature. +} + +void print_sce_signature_info(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset) +{ _print_sce_signature(fp, ctxt->sig); - - //Print signature status. _print_sce_signature_status(fp, ctxt, keyset); } diff --git a/src/sce.h b/src/sce.h index 37834e3..be07cf0 100644 --- a/src/sce.h +++ b/src/sce.h @@ -17,12 +17,12 @@ /*! Header align. */ #define HEADER_ALIGN 0x80 -/*! SCE header magic value ("SCE\0"). */ -#define SCE_HEADER_MAGIC 0x53434500 +/*! Cert file magic value ("SCE\0"). */ +#define CF_MAGIC 0x53434500 -/*! SCE header versions. */ -/*! Header version 2. */ -#define SCE_HEADER_VERSION_2 2 +/*! Cert file versions. */ +/*! Cert file version 2. */ +#define CF_VERSION_2 2 /*! Key revisions. */ #define KEY_REVISION_0 0x00 @@ -52,15 +52,15 @@ //#define KEY_REVISION_ 0x18 #define KEY_REVISION_DEBUG 0x8000 -/*! SCE header types. */ -/*! SELF header. */ -#define SCE_HEADER_TYPE_SELF 1 -/*! RVK header. */ -#define SCE_HEADER_TYPE_RVK 2 -/*! PKG header. */ -#define SCE_HEADER_TYPE_PKG 3 -/*! SPP header. */ -#define SCE_HEADER_TYPE_SPP 4 +/*! Cert file categories. */ +/*! SELF file. */ +#define CF_CATEGORY_SELF 1 +/*! RVK file. */ +#define CF_CATEGORY_RVK 2 +/*! PKG file. */ +#define CF_CATEGORY_PKG 3 +/*! SPP file. */ +#define CF_CATEGORY_SPP 4 /*! Sub header types. */ /*! SCE version header. */ @@ -108,6 +108,9 @@ /*! Section is compressed. */ #define METADATA_SECTION_COMPRESSED 2 +/*! Signature types. */ +#define SIGNATURE_ALGORITHM_ECDSA 1 + /*! Signature sizes. */ /*! Signature S part size. */ #define SIGNATURE_S_SIZE 21 @@ -124,23 +127,23 @@ /*! SCE version present. */ #define SCE_VERSION_PRESENT 1 -/*! SELF types. */ +/*! Program types. */ /*! lv0. */ -#define SELF_TYPE_LV0 1 +#define PROGRAM_TYPE_LV0 1 /*! lv1. */ -#define SELF_TYPE_LV1 2 +#define PROGRAM_TYPE_LV1 2 /*! lv2. */ -#define SELF_TYPE_LV2 3 +#define PROGRAM_TYPE_LV2 3 /*! Application. */ -#define SELF_TYPE_APP 4 +#define PROGRAM_TYPE_APP 4 /*! Isolated SPU module. */ -#define SELF_TYPE_ISO 5 +#define PROGRAM_TYPE_ISO 5 /*! Secure loader. */ -#define SELF_TYPE_LDR 6 +#define PROGRAM_TYPE_LDR 6 /*! Unknown type 7. */ -#define SELF_TYPE_UNK_7 7 +#define PROGRAM_TYPE_UNK_7 7 /*! NPDRM application. */ -#define SELF_TYPE_NPDRM 8 +#define PROGRAM_TYPE_NPDRM 8 /*! NPDRM control info magic value ("NPD\0"). */ #define NP_CI_MAGIC 0x4E504400 @@ -157,8 +160,8 @@ #define NP_TYPE_USPRX (NP_TYPE_UPDATE | NP_TYPE_SPRX) #define NP_TYPE_UEXEC (NP_TYPE_UPDATE | NP_TYPE_EXEC) -/*! SCE header. */ -typedef struct _sce_header +/*! Cert file header. */ +typedef struct _cert_file_header { /*! Magic value. */ u32 magic; @@ -166,22 +169,22 @@ typedef struct _sce_header u32 version; /*! Key revision. */ u16 key_revision; - /*! Header type. */ - u16 header_type; - /*! Metadata offset. */ - u32 metadata_offset; - /*! Header length. */ - u64 header_len; - /*! Length of encapsulated data. */ - u64 data_len; -} sce_header_t; + /*! File category. */ + u16 category; + /*! Extended header size. */ + u32 ext_header_size; + /*! Offset of encapsulated file. */ + u64 file_offset; + /*! Size of encapsulated file. */ + u64 file_size; +} cert_file_header_t; /*! SELF header. */ typedef struct _self_header { /*! Header type. */ u64 header_type; - /*! Application info offset. */ + /*! Program info offset. */ u64 app_info_offset; /*! ELF offset. */ u64 elf_offset; @@ -218,7 +221,8 @@ typedef struct _metadata_header { /*! Signature input length. */ u64 sig_input_length; - u32 unknown_0; + /*! Signature algorithm. */ + u32 sig_algorithm; /*! Section count. */ u32 section_count; /*! Key count. */ @@ -305,7 +309,7 @@ typedef struct _sce_version_data_30 #define VENDOR_TERRITORY_MASK 0xFF000000 #define VENDOR_ID_MASK 0x00FFFFFF -/*! Application info. */ +/*! Program info. */ typedef struct _app_info { /*! Auth ID. */ @@ -313,7 +317,7 @@ typedef struct _app_info /*! Vendor ID. */ u32 vendor_id; /*! SELF type. */ - u32 self_type; + u32 program_type; /*! Version. */ u64 version; /*! Padding. */ @@ -449,7 +453,7 @@ typedef struct _sce_section_ctxt /*! Offset. */ u32 offset; /*! May be compressed. */ - BOOL may_compr; + bool may_compr; } sce_section_ctxt_t; typedef struct _makeself_ctxt @@ -482,8 +486,8 @@ typedef struct _sce_buffer_ctxt /*! SCE file buffer. */ u8 *scebuffer; - /*! SCE header. */ - sce_header_t *sceh; + /*! Cert file header. */ + cert_file_header_t *cfh; /*! File type dependent header. */ union { @@ -491,7 +495,7 @@ typedef struct _sce_buffer_ctxt { /*! SELF header. */ self_header_t *selfh; - /*! Application info. */ + /*! Program info. */ app_info_t *ai; /*! Section info. */ section_info_t *si; @@ -517,18 +521,18 @@ typedef struct _sce_buffer_ctxt signature_t *sig; /*! Metadata decrypted? */ - BOOL mdec; + bool mdec; /*! Data layout. */ - /*! SCE header offset. */ - u32 off_sceh; + /*! Cert file header offset. */ + u32 off_cfh; union { struct { /*! SELF header offset. */ u32 off_selfh; - /*! Application info offset. */ + /*! Program info offset. */ u32 off_ai; /*! ELF header offset. */ u32 off_ehdr; @@ -575,10 +579,10 @@ sce_buffer_ctxt_t *sce_create_ctxt_from_buffer(u8 *scebuffer); sce_buffer_ctxt_t *sce_create_ctxt_build_self(u8 *elf, u32 elf_len); /*! Add data section to SCE context. */ -void sce_add_data_section(sce_buffer_ctxt_t *ctxt, void *buffer, u32 size, BOOL may_compr); +void sce_add_data_section(sce_buffer_ctxt_t *ctxt, void *buffer, u32 size, bool may_compr); /*! Set metadata section header. */ -void sce_set_metash(sce_buffer_ctxt_t *ctxt, u32 type, BOOL encrypted, u32 idx); +void sce_set_metash(sce_buffer_ctxt_t *ctxt, u32 type, bool encrypted, u32 idx); /*! Compress data. */ void sce_compress_data(sce_buffer_ctxt_t *ctxt); @@ -587,20 +591,26 @@ void sce_compress_data(sce_buffer_ctxt_t *ctxt); void sce_layout_ctxt(sce_buffer_ctxt_t *ctxt); /*! Encrypt context. */ -BOOL sce_encrypt_ctxt(sce_buffer_ctxt_t *ctxt, u8 *keyset); +bool sce_encrypt_ctxt(sce_buffer_ctxt_t *ctxt, u8 *keyset); /*! Write context to file. */ -BOOL sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname); +bool sce_write_ctxt(sce_buffer_ctxt_t *ctxt, s8 *fname); /*! Decrypt header (use passed metadata_into if not NULL). */ -BOOL sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset); +bool sce_decrypt_header(sce_buffer_ctxt_t *ctxt, u8 *metadata_info, u8 *keyset); /*! Decrypt data. */ -BOOL sce_decrypt_data(sce_buffer_ctxt_t *ctxt); +bool sce_decrypt_data(sce_buffer_ctxt_t *ctxt); + +/*! Print SCE header info. */ +void cf_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt); /*! Print SCE file info. */ void sce_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset); +/*! Print SCE signature status. */ +void print_sce_signature_info(FILE *fp, sce_buffer_ctxt_t *ctxt, u8 *keyset); + /*! Get version string from version. */ s8 *sce_version_to_str(u64 version); diff --git a/src/self.cpp b/src/self.cpp index 613e3f1..85084d9 100644 --- a/src/self.cpp +++ b/src/self.cpp @@ -2,6 +2,7 @@ * Copyright (c) 2011-2013 by naehrwert * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -47,9 +48,10 @@ static void _get_phdr_flags(s8 *str, u64 flags) void _print_self_header(FILE *fp, self_header_t *h) { - fprintf(fp, "[*] SELF Header:\n"); - fprintf(fp, " Header Type 0x%016llX\n", _ES64(h->header_type)); - fprintf(fp, " App Info Offset 0x%016llX\n", _ES64(h->app_info_offset)); + fprintf(fp, "[*] Extended Header:\n"); + fprintf(fp, "[*] Signed Elf Header:\n"); + fprintf(fp, " Version 0x%016llX\n", _ES64(h->header_type)); + fprintf(fp, " Program Info Offset 0x%016llX\n", _ES64(h->app_info_offset)); fprintf(fp, " ELF Offset 0x%016llX\n", _ES64(h->elf_offset)); fprintf(fp, " PH Offset 0x%016llX\n", _ES64(h->phdr_offset)); fprintf(fp, " SH Offset 0x%016llX\n", _ES64(h->shdr_offset)); @@ -64,7 +66,7 @@ void _print_app_info(FILE *fp, app_info_t *ai) { const s8 *name; - fprintf(fp, "[*] Application Info:\n"); + fprintf(fp, "[*] Program Ident Header:\n"); name = _get_name(_auth_ids, _ES64(ai->auth_id)); if(name != NULL) @@ -86,11 +88,16 @@ void _print_app_info(FILE *fp, app_info_t *ai) else fprintf(fp, " Vendor-ID 0x%08X\n", _ES32(ai->vendor_id)); - name = _get_name(_self_types, _ES32(ai->self_type)); + name = _get_name(_program_types, _ES32(ai->program_type)); if(name != NULL) - fprintf(fp, " SELF-Type [%s]\n", name); + { + fprintf(fp, " Type ", name); + _PRINT_RAW(fp, "0x%08X ", _ES32(ai->program_type)); + fprintf(fp, "[%s]\n", name); + } + else - fprintf(fp, " SELF-Type 0x%08X\n", _ES32(ai->self_type)); + fprintf(fp, " Type 0x%08X\n", _ES32(ai->program_type)); fprintf(fp, " Version %s\n", sce_version_to_str(_ES64(ai->version))); //fprintf(fp, " padding 0x%016llX\n", _ES64(ai->padding)); @@ -105,8 +112,8 @@ void _print_section_info_header(FILE *fp) void _print_section_info(FILE *fp, section_info_t *si, u32 idx) { fprintf(fp, " %03d %08X %08X %s %08X %08X %s\n", - idx, (u32)si->offset, (u32)si->size, si->compressed == 2 ? "[YES]" : "[NO ]", - si->unknown_0, si->unknown_1, si->encrypted == 1 ? "[YES]" : "[NO ]"); + idx, (u32)_ES64(si->offset), (u32)_ES64(si->size), _ES32(si->compressed) == 2 ? "[YES]" : "[NO ]", + _ES32(si->unknown_0), _ES32(si->unknown_1), _ES32(si->encrypted) == 1 ? "[YES]" : "[NO ]"); } void _print_sce_version(FILE *fp, sce_version_t *sv) @@ -149,11 +156,10 @@ void _print_control_info(FILE *fp, control_info_t *ci) else if(_ES32(ci->size) == 0x40) { ci_data_digest_40_t *dig = (ci_data_digest_40_t *)((u8 *)ci + sizeof(control_info_t)); - _es_ci_data_digest_40(dig); _hexdump(fp, " Digest 1 ", 0, dig->digest1, 20, FALSE); _hexdump(fp, " Digest 2 ", 0, dig->digest2, 20, FALSE); - if(dig->fw_version != 0) - fprintf(fp, " FW Version %d [%02d.%02d]\n", (u32)dig->fw_version, ((u32)dig->fw_version)/10000, (((u32)dig->fw_version)%10000)/100); + if(_ES64(dig->fw_version) != 0) + fprintf(fp, " FW Version %d [%02d.%02d]\n", (u32)_ES64(dig->fw_version), ((u32)_ES64(dig->fw_version))/10000, (((u32)_ES64(dig->fw_version))%10000)/100); } break; case CONTROL_INFO_TYPE_NPDRM: @@ -225,19 +231,19 @@ void _print_control_info(FILE *fp, control_info_t *ci) static void _print_cap_flags_flags(FILE *fp, oh_data_cap_flags_t *cf) { - if(cf->flags & 0x01) + if(_ES64(cf->flags) & 0x01) fprintf(fp, "0x01 "); - if(cf->flags & 0x02) + if(_ES64(cf->flags) & 0x02) fprintf(fp, "0x02 "); - if(cf->flags & 0x04) + if(_ES64(cf->flags) & 0x04) fprintf(fp, "0x04 "); - if(cf->flags & CAP_FLAG_REFTOOL) + if(_ES64(cf->flags) & CAP_FLAG_REFTOOL) fprintf(fp, "REFTOOL "); - if(cf->flags & CAP_FLAG_DEBUG) + if(_ES64(cf->flags) & CAP_FLAG_DEBUG) fprintf(fp, "DEBUG "); - if(cf->flags & CAP_FLAG_RETAIL) + if(_ES64(cf->flags) & CAP_FLAG_RETAIL) fprintf(fp, "RETAIL "); - if(cf->flags & CAP_FLAG_SYSDBG) + if(_ES64(cf->flags) & CAP_FLAG_SYSDBG) fprintf(fp, "SYSDBG "); } @@ -264,27 +270,25 @@ void _print_opt_header(FILE *fp, opt_header_t *oh) _IF_RAW(_hexdump(fp, " Flags", 0, (u8 *)cf, sizeof(oh_data_cap_flags_t), FALSE)); - _es_oh_data_cap_flags(cf); + // _es_oh_data_cap_flags(cf); - fprintf(fp, " unknown_3 0x%016llX\n", cf->unk3); - fprintf(fp, " unknown_4 0x%016llX\n", cf->unk4); + fprintf(fp, " unknown_3 0x%016llX\n", _ES64(cf->unk3)); + fprintf(fp, " unknown_4 0x%016llX\n", _ES64(cf->unk4)); - fprintf(fp, " Flags 0x%016llX [ ", cf->flags); + fprintf(fp, " Flags 0x%016llX [ ", _ES64(cf->flags)); _print_cap_flags_flags(fp, cf); fprintf(fp, "]\n"); - fprintf(fp, " unknown_6 0x%08X\n", cf->unk6); - fprintf(fp, " unknown_7 0x%08X\n", cf->unk7); + fprintf(fp, " unknown_6 0x%08X\n", _ES32(cf->unk6)); + fprintf(fp, " unknown_7 0x%08X\n", _ES32(cf->unk7)); } break; -#ifdef CONFIG_DUMP_INDIV_SEED case OPT_HEADER_TYPE_INDIV_SEED: { u8 *is = (u8 *)oh + sizeof(opt_header_t); - _hexdump(fp, " Seed", 0, is, _ES32(oh->size) - sizeof(opt_header_t), TRUE); + _hexdump(fp, " Seed", 0, is, _ES32(oh->size) - sizeof(opt_header_t), FALSE); } break; -#endif } } @@ -294,26 +298,26 @@ void _print_elf32_ehdr(FILE *fp, Elf32_Ehdr *h) fprintf(fp, "[*] ELF32 Header:\n"); - name = _get_name(_e_types, h->e_type); + name = _get_name(_e_types, _ES16(h->e_type)); if(name != NULL) fprintf(fp, " Type [%s]\n", name); else - fprintf(fp, " Type 0x%04X\n", h->e_type); + fprintf(fp, " Type 0x%04X\n", _ES16(h->e_type)); - name = _get_name(_e_machines, h->e_machine); + name = _get_name(_e_machines, _ES16(h->e_machine)); if(name != NULL) fprintf(fp, " Machine [%s]\n", name); else - fprintf(fp, " Machine 0x%04X\n", h->e_machine); + fprintf(fp, " Machine 0x%04X\n", _ES16(h->e_machine)); - fprintf(fp, " Version 0x%08X\n", h->e_version); - fprintf(fp, " Entry 0x%08X\n", h->e_entry); - fprintf(fp, " Program Headers Offset 0x%08X\n", h->e_phoff); - fprintf(fp, " Section Headers Offset 0x%08X\n", h->e_shoff); - fprintf(fp, " Flags 0x%08X\n", h->e_flags); - fprintf(fp, " Program Headers Count %04d\n", h->e_phnum); - fprintf(fp, " Section Headers Count %04d\n", h->e_shnum); - fprintf(fp, " SH String Index %04d\n", h->e_shstrndx); + fprintf(fp, " Version 0x%08X\n", _ES32(h->e_version)); + fprintf(fp, " Entry 0x%08X\n", _ES32(h->e_entry)); + fprintf(fp, " Program Headers Offset 0x%08X\n", _ES32(h->e_phoff)); + fprintf(fp, " Section Headers Offset 0x%08X\n", _ES32(h->e_shoff)); + fprintf(fp, " Flags 0x%08X\n", _ES32(h->e_flags)); + fprintf(fp, " Program Headers Count %04d\n", _ES16(h->e_phnum)); + fprintf(fp, " Section Headers Count %04d\n", _ES16(h->e_shnum)); + fprintf(fp, " SH String Index %04d\n", _ES16(h->e_shstrndx)); } void _print_elf64_ehdr(FILE *fp, Elf64_Ehdr *h) @@ -322,26 +326,26 @@ void _print_elf64_ehdr(FILE *fp, Elf64_Ehdr *h) fprintf(fp, "[*] ELF64 Header:\n"); - name = _get_name(_e_types, h->e_type); + name = _get_name(_e_types, _ES16(h->e_type)); if(name != NULL) fprintf(fp, " Type [%s]\n", name); else - fprintf(fp, " Type 0x%04X\n", h->e_type); + fprintf(fp, " Type 0x%04X\n", _ES16(h->e_type)); - name = _get_name(_e_machines, h->e_machine); + name = _get_name(_e_machines, _ES16(h->e_machine)); if(name != NULL) fprintf(fp, " Machine [%s]\n", name); else - fprintf(fp, " Machine 0x%04X\n", h->e_machine); + fprintf(fp, " Machine 0x%04X\n", _ES16(h->e_machine)); - fprintf(fp, " Version 0x%08X\n", h->e_version); - fprintf(fp, " Entry 0x%016llX\n", h->e_entry); - fprintf(fp, " Program Headers Offset 0x%016llX\n", h->e_phoff); - fprintf(fp, " Section Headers Offset 0x%016llX\n", h->e_shoff); - fprintf(fp, " Flags 0x%08X\n", h->e_flags); - fprintf(fp, " Program Headers Count %04d\n", h->e_phnum); - fprintf(fp, " Section Headers Count %04d\n", h->e_shnum); - fprintf(fp, " SH String Index %04d\n", h->e_shstrndx); + fprintf(fp, " Version 0x%08X\n", _ES32(h->e_version)); + fprintf(fp, " Entry 0x%016llX\n", _ES64(h->e_entry)); + fprintf(fp, " Program Headers Offset 0x%016llX\n", _ES64(h->e_phoff)); + fprintf(fp, " Section Headers Offset 0x%016llX\n", _ES64(h->e_shoff)); + fprintf(fp, " Flags 0x%08X\n", _ES32(h->e_flags)); + fprintf(fp, " Program Headers Count %04d\n", _ES16(h->e_phnum)); + fprintf(fp, " Section Headers Count %04d\n", _ES16(h->e_shnum)); + fprintf(fp, " SH String Index %04d\n", _ES16(h->e_shstrndx)); } void _print_elf32_shdr_header(FILE *fp) @@ -355,24 +359,24 @@ void _print_elf32_shdr(FILE *fp, Elf32_Shdr *h, u32 idx) const s8 *name; s8 flags[4]; - _get_shdr_flags(flags, h->sh_flags); + _get_shdr_flags(flags, _ES32(h->sh_flags)); - fprintf(fp, " %03d %04X ", idx, h->sh_name); + fprintf(fp, " %03d %04X ", idx, _ES32(h->sh_name)); - name = _get_name(_sh_types, h->sh_type); + name = _get_name(_sh_types, _ES32(h->sh_type)); if(name != NULL) fprintf(fp, "%-13s ", name); else - fprintf(fp, "%08X ", h->sh_type); + fprintf(fp, "%08X ", _ES32(h->sh_type)); fprintf(fp, "%s %05X %05X %05X %02X %05X %03d\n", - flags, h->sh_addr, h->sh_offset, h->sh_size, h->sh_entsize, h->sh_addralign, h->sh_link); + flags, _ES32(h->sh_addr), _ES32(h->sh_offset), _ES32(h->sh_size), _ES32(h->sh_entsize), _ES32(h->sh_addralign), _ES32(h->sh_link)); } void _print_elf64_shdr_header(FILE *fp) { fprintf(fp, "[*] ELF64 Section Headers:\n"); - fprintf(fp, " Idx Name Type Flags Address Offset Size ES Align LK\n"); + fprintf(fp, " Idx Name Type Flags Address Offset Size ES Align LK\n"); } void _print_elf64_shdr(FILE *fp, Elf64_Shdr *h, u32 idx) @@ -380,18 +384,18 @@ void _print_elf64_shdr(FILE *fp, Elf64_Shdr *h, u32 idx) const s8 *name; s8 flags[4]; - _get_shdr_flags(flags, h->sh_flags); + _get_shdr_flags(flags, _ES64(h->sh_flags)); - fprintf(fp, " %03d %04X ", idx, h->sh_name); + fprintf(fp, " %03d %04X ", idx, _ES32(h->sh_name)); - name = _get_name(_sh_types, h->sh_type); + name = _get_name(_sh_types, _ES32(h->sh_type)); if(name != NULL) fprintf(fp, "%-13s ", name); else - fprintf(fp, "%08X ", h->sh_type); + fprintf(fp, "%08X ", _ES32(h->sh_type)); - fprintf(fp, "%s %08X %08X %08X %04X %08X %03d\n", - flags, (u32)h->sh_addr, (u32)h->sh_offset, (u32)h->sh_size, (u32)h->sh_entsize, (u32)h->sh_addralign, h->sh_link); + fprintf(fp, "%s %016llX %08X %08X %04X %08X %03d\n", + flags, (u64)_ES64(h->sh_addr), (u32)_ES64(h->sh_offset), (u32)_ES64(h->sh_size), (u32)_ES64(h->sh_entsize), (u32)_ES64(h->sh_addralign), _ES32(h->sh_link)); } void _print_elf32_phdr_header(FILE *fp) @@ -406,24 +410,24 @@ void _print_elf32_phdr(FILE *fp, Elf32_Phdr *h, u32 idx) s8 flags[4]; - _get_phdr_flags(flags, h->p_flags); + _get_phdr_flags(flags, _ES32(h->p_flags)); fprintf(fp, " %03d ", idx); - name = _get_name(_ph_types, h->p_type); + name = _get_name(_ph_types, _ES32(h->p_type)); if(name != NULL) fprintf(fp, "%-7s ", name); else - fprintf(fp, "0x%08X ", h->p_type); + fprintf(fp, "0x%08X ", _ES32(h->p_type)); fprintf(fp, "%05X %05X %05X %05X %05X %s %05X\n", - h->p_offset, h->p_vaddr, h->p_paddr, h->p_filesz, h->p_memsz, flags, h->p_align); + _ES32(h->p_offset), _ES32(h->p_vaddr), _ES32(h->p_paddr), _ES32(h->p_filesz), _ES32(h->p_memsz), flags, _ES32(h->p_align)); } void _print_elf64_phdr_header(FILE *fp) { fprintf(fp, "[*] ELF64 Program Headers:\n"); - fprintf(fp, " Idx Type Offset VAddr PAddr FileSize MemSize PPU SPU RSX Align\n"); + fprintf(fp, " Idx Type Offset VAddr PAddr FileSize MemSize PPU SPU RSX Align\n"); } void _print_elf64_phdr(FILE *fp, Elf64_Phdr *h, u32 idx) @@ -432,29 +436,29 @@ void _print_elf64_phdr(FILE *fp, Elf64_Phdr *h, u32 idx) s8 ppu[4], spu[4], rsx[4]; - _get_phdr_flags(ppu, h->p_flags); - _get_phdr_flags(spu, h->p_flags >> 20); - _get_phdr_flags(rsx, h->p_flags >> 24); + _get_phdr_flags(ppu, _ES32(h->p_flags)); + _get_phdr_flags(spu, _ES32(h->p_flags) >> 20); + _get_phdr_flags(rsx, _ES32(h->p_flags) >> 24); fprintf(fp, " %03d ", idx); - name = _get_name(_ph_types, h->p_type); + name = _get_name(_ph_types, _ES32(h->p_type)); if(name != NULL) fprintf(fp, "%-8s ", name); else - fprintf(fp, "%08X ", h->p_type); + fprintf(fp, "%08X ", _ES32(h->p_type)); - fprintf(fp, "%08X %08X %08X %08X %08X %s %s %s %08X\n", - (u32)h->p_offset, (u32)h->p_vaddr, (u32)h->p_paddr, (u32)h->p_filesz, (u32)h->p_memsz, ppu, spu, rsx, (u32)h->p_align); + fprintf(fp, "%08X %016llX %016llX %08X %08X %s %s %s %08X\n", + (u32)_ES64(h->p_offset), (u64)_ES64(h->p_vaddr), (u64)_ES64(h->p_paddr), (u32)_ES64(h->p_filesz), (u32)_ES64(h->p_memsz), ppu, spu, rsx, (u32)_ES64(h->p_align)); } -BOOL self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) +bool self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) { - u32 i, self_type; + u32 i, program_type; const u8 *eident; //Check for SELF. - if(_ES16(ctxt->sceh->header_type) != SCE_HEADER_TYPE_SELF) + if(_ES16(ctxt->cfh->category) != CF_CATEGORY_SELF) return FALSE; //Print SELF infos. @@ -468,37 +472,19 @@ BOOL self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) LIST_FOREACH(iter, ctxt->self.cis) _print_control_info(fp, (control_info_t *)iter->value); - //Print optional headers. - if(ctxt->mdec == TRUE) - { - LIST_FOREACH(iter, ctxt->self.ohs) - { -#ifndef CONFIG_DUMP_INDIV_SEED - if(_ES32(((opt_header_t *)iter->value)->type) != OPT_HEADER_TYPE_INDIV_SEED) - _print_opt_header(fp, (opt_header_t *)iter->value); -#else - _print_opt_header(fp, (opt_header_t *)iter->value); -#endif - } - } - - self_type = _ES32(ctxt->self.ai->self_type); + program_type = _ES32(ctxt->self.ai->program_type); eident = ctxt->scebuffer + _ES64(ctxt->self.selfh->elf_offset); //SPU is 32 bit. - if(self_type == SELF_TYPE_LDR || self_type == SELF_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) + if(program_type == PROGRAM_TYPE_LDR || program_type == PROGRAM_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) { //32 bit ELF. Elf32_Ehdr *eh = (Elf32_Ehdr *)(ctxt->scebuffer + _ES64(ctxt->self.selfh->elf_offset)); - _es_elf32_ehdr(eh); //Print section infos. _print_section_info_header(fp); - for(i = 0; i < eh->e_phnum; i++) - { - _es_section_info(&ctxt->self.si[i]); + for(i = 0; i < _ES16(eh->e_phnum); i++) _print_section_info(fp, &ctxt->self.si[i], i); - } //Print ELF header. _print_elf32_ehdr(fp, eh); @@ -507,37 +493,30 @@ BOOL self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) //Print program headers. _print_elf32_phdr_header(fp); - for(i = 0; i < eh->e_phnum; i++) - { - _es_elf32_phdr(&ph[i]); + for(i = 0; i < _ES16(eh->e_phnum); i++) _print_elf32_phdr(fp, &ph[i], i); - } - if(eh->e_shnum > 0) + if(_ES16(eh->e_shnum) > 0) { Elf32_Shdr *sh = (Elf32_Shdr *)(ctxt->scebuffer + _ES64(ctxt->self.selfh->shdr_offset)); //Print section headers. _print_elf32_shdr_header(fp); - for(i = 0; i < eh->e_shnum; i++) - { - _es_elf32_shdr(&sh[i]); + for(i = 0; i < _ES16(eh->e_shnum); i++) _print_elf32_shdr(fp, &sh[i], i); - } } } else { //64 bit ELF. Elf64_Ehdr *eh = (Elf64_Ehdr *)(ctxt->scebuffer + _ES64(ctxt->self.selfh->elf_offset)); - _es_elf64_ehdr(eh); //Print section infos. - _print_section_info_header(fp); - for(i = 0; i < eh->e_phnum; i++) + if(ctxt->self.si != NULL) { - _es_section_info(&ctxt->self.si[i]); - _print_section_info(fp, &ctxt->self.si[i], i); + _print_section_info_header(fp); + for(i = 0; i < _ES16(eh->e_phnum); i++) + _print_section_info(fp, &ctxt->self.si[i], i); } //Print ELF header. @@ -547,64 +526,74 @@ BOOL self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt) //Print program headers. _print_elf64_phdr_header(fp); - for(i = 0; i < eh->e_phnum; i++) - { - _es_elf64_phdr(&ph[i]); + + for(i = 0; i < _ES16(eh->e_phnum); i++) _print_elf64_phdr(fp, &ph[i], i); - } - if(eh->e_shnum > 0) + if(_ES16(eh->e_shnum) > 0) { + Elf64_Shdr *sh = (Elf64_Shdr *)(ctxt->scebuffer + _ES64(ctxt->self.selfh->shdr_offset)); //Print section headers. _print_elf64_shdr_header(fp); - for(i = 0; i < eh->e_shnum; i++) - { - _es_elf64_shdr(&sh[i]); + for(i = 0; i < _ES16(eh->e_shnum); i++) _print_elf64_shdr(fp, &sh[i], i); - } } } return TRUE; } +bool self_print_encrypted_info(FILE *fp, sce_buffer_ctxt_t *ctxt) +{ + //Print optional headers. + if(ctxt->mdec == TRUE) + if (_ES64(ctxt->metah->opt_header_size) > 0) + { + LIST_FOREACH(iter, ctxt->self.ohs) + _print_opt_header(fp, (opt_header_t *)iter->value); + } + return TRUE; +} + //TODO: maybe implement better. -BOOL self_write_to_elf(sce_buffer_ctxt_t *ctxt, const s8 *elf_out) +bool self_write_to_elf(sce_buffer_ctxt_t *ctxt, const s8 *elf_out) { FILE *fp; - u32 i, self_type; + u32 i, program_type; const u8 *eident; //Check for SELF. - if(_ES16(ctxt->sceh->header_type) != SCE_HEADER_TYPE_SELF) + if(_ES16(ctxt->cfh->category) != CF_CATEGORY_SELF) return FALSE; if((fp = fopen(elf_out, "wb")) == NULL) return FALSE; - self_type = _ES32(ctxt->self.ai->self_type); + program_type = _ES32(ctxt->self.ai->program_type); eident = ctxt->scebuffer + _ES64(ctxt->self.selfh->elf_offset); //SPU is 32 bit. - if(self_type == SELF_TYPE_LDR || self_type == SELF_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) + if(program_type == PROGRAM_TYPE_LDR || program_type == PROGRAM_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) { -#ifdef CONFIG_DUMP_INDIV_SEED - /* //Print individuals seed. - if(self_type == SELF_TYPE_ISO) + if(program_type == PROGRAM_TYPE_ISO) { - u8 *indiv_seed = (u8 *)ctxt->self.ish + sizeof(iseed_header_t); - s8 ifile[256]; - sprintf(ifile, "%s.indiv_seed.bin", elf_out); - FILE *ifp = fopen(ifile, "wb"); - fwrite(indiv_seed, sizeof(u8), ctxt->self.ish->size - sizeof(iseed_header_t), ifp); - fclose(ifp); + LIST_FOREACH(iter, ctxt->self.ohs) + { + opt_header_t *oh = (opt_header_t *)iter->value; + if (_ES32(oh->type) == OPT_HEADER_TYPE_INDIV_SEED) + { + s8 ifile[256]; + sprintf(ifile, "%s.indiv_seed.bin", elf_out); + FILE *ifp = fopen(ifile, "wb"); + fwrite(((u8 *)oh) + sizeof(opt_header_t), sizeof(u8), _ES32(oh->size) - sizeof(opt_header_t), ifp); + printf("[*] SEED dumped to %s.\n", ifile); + } + } } - */ -#endif //32 bit ELF. Elf32_Ehdr ceh, *eh = (Elf32_Ehdr *)(ctxt->scebuffer + _ES64(ctxt->self.selfh->elf_offset)); @@ -717,21 +706,21 @@ static u8 _static_control_digest[0x14] = 0x62, 0x7C, 0xB1, 0x80, 0x8A, 0xB9, 0x38, 0xE3, 0x2C, 0x8C, 0x09, 0x17, 0x08, 0x72, 0x6A, 0x57, 0x9E, 0x25, 0x86, 0xE4 }; -static BOOL _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) +static bool _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) { control_info_t *ci; - u32 self_type = _ES32(ctxt->self.ai->self_type); + u32 program_type = _ES32(ctxt->self.ai->program_type); //Step 1. - switch(self_type) + switch(program_type) { - case SELF_TYPE_LV0: - case SELF_TYPE_LV1: - case SELF_TYPE_LV2: - case SELF_TYPE_APP: - case SELF_TYPE_ISO: - case SELF_TYPE_LDR: - case SELF_TYPE_NPDRM: //TODO: <-- figure more out. + case PROGRAM_TYPE_LV0: + case PROGRAM_TYPE_LV1: + case PROGRAM_TYPE_LV2: + case PROGRAM_TYPE_APP: + case PROGRAM_TYPE_ISO: + case PROGRAM_TYPE_LDR: + case PROGRAM_TYPE_NPDRM: //TODO: <-- figure more out. { //Add control flags. ci = (control_info_t *)malloc(sizeof(control_info_t) + sizeof(ci_data_flags_t)); @@ -753,21 +742,21 @@ static BOOL _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) } //Step 2. - switch(self_type) + switch(program_type) { - case SELF_TYPE_LV0: - case SELF_TYPE_LV1: - case SELF_TYPE_LV2: - case SELF_TYPE_APP: - case SELF_TYPE_ISO: - case SELF_TYPE_LDR: - case SELF_TYPE_NPDRM: + case PROGRAM_TYPE_LV0: + case PROGRAM_TYPE_LV1: + case PROGRAM_TYPE_LV2: + case PROGRAM_TYPE_APP: + case PROGRAM_TYPE_ISO: + case PROGRAM_TYPE_LDR: + case PROGRAM_TYPE_NPDRM: { //Add digest 0x40. ci = (control_info_t *)malloc(sizeof(control_info_t) + sizeof(ci_data_digest_40_t)); ci->type = _ES32(CONTROL_INFO_TYPE_DIGEST); ci->size = _ES32(sizeof(control_info_t) + sizeof(ci_data_digest_40_t)); - if(self_type == SELF_TYPE_NPDRM) + if(program_type == PROGRAM_TYPE_NPDRM) ci->next = _ES64(1); else ci->next = _ES64(0); @@ -778,7 +767,7 @@ static BOOL _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) sha1(ctxt->makeself->elf, ctxt->makeself->elf_len, cid->digest2); //TODO: check that. - if(self_type == SELF_TYPE_NPDRM) + if(program_type == PROGRAM_TYPE_NPDRM) cid->fw_version = sce_hexver_to_decver(sconf->fw_version); else cid->fw_version = 0; @@ -792,9 +781,9 @@ static BOOL _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) } //Step 3. - switch(self_type) + switch(program_type) { - case SELF_TYPE_NPDRM: + case PROGRAM_TYPE_NPDRM: { //Add NPDRM control info. if(sconf->npdrm_config == NULL) @@ -822,34 +811,34 @@ static BOOL _create_control_infos(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) return TRUE; } -static void _set_cap_flags(u32 self_type, oh_data_cap_flags_t *capf) +static void _set_cap_flags(u32 program_type, oh_data_cap_flags_t *capf) { - switch(self_type) + switch(program_type) { - case SELF_TYPE_LV0: + case PROGRAM_TYPE_LV0: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL | 0x3; //0x7B; capf->unk6 = 1; break; - case SELF_TYPE_LV1: + case PROGRAM_TYPE_LV1: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL | 0x3; //0x7B; capf->unk6 = 1; break; - case SELF_TYPE_LV2: + case PROGRAM_TYPE_LV2: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL | 0x3; //0x7B; capf->unk6 = 1; break; - case SELF_TYPE_APP: + case PROGRAM_TYPE_APP: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL | 0x3; //0x7B; capf->unk6 = 1; capf->unk7 = 0x20000; break; - case SELF_TYPE_ISO: + case PROGRAM_TYPE_ISO: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL; //0x78; break; - case SELF_TYPE_LDR: + case PROGRAM_TYPE_LDR: capf->flags = CAP_FLAG_SYSDBG | CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL; //0x78; break; - case SELF_TYPE_NPDRM: + case PROGRAM_TYPE_NPDRM: capf->flags = CAP_FLAG_RETAIL | CAP_FLAG_DEBUG | CAP_FLAG_REFTOOL | 0x3; //0x3B; capf->unk6 = 1; capf->unk7 = 0x2000; @@ -859,27 +848,27 @@ static void _set_cap_flags(u32 self_type, oh_data_cap_flags_t *capf) _es_oh_data_cap_flags(capf); } -static BOOL _create_optional_headers(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) +static bool _create_optional_headers(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) { opt_header_t *oh; - u32 self_type = _ES32(ctxt->self.ai->self_type); + u32 program_type = _ES32(ctxt->self.ai->program_type); //Step 1. - switch(self_type) + switch(program_type) { - case SELF_TYPE_LV0: - case SELF_TYPE_LV1: - case SELF_TYPE_LV2: - case SELF_TYPE_APP: - case SELF_TYPE_ISO: - case SELF_TYPE_LDR: - case SELF_TYPE_NPDRM: + case PROGRAM_TYPE_LV0: + case PROGRAM_TYPE_LV1: + case PROGRAM_TYPE_LV2: + case PROGRAM_TYPE_APP: + case PROGRAM_TYPE_ISO: + case PROGRAM_TYPE_LDR: + case PROGRAM_TYPE_NPDRM: { //Add capability flags. oh = (opt_header_t *)malloc(sizeof(opt_header_t) + sizeof(oh_data_cap_flags_t)); oh->type = _ES32(OPT_HEADER_TYPE_CAP_FLAGS); oh->size = _ES32(sizeof(opt_header_t) + sizeof(oh_data_cap_flags_t)); - if(self_type == SELF_TYPE_ISO) + if(program_type == PROGRAM_TYPE_ISO) oh->next = _ES64(1); else oh->next = _ES64(0); @@ -889,7 +878,7 @@ static BOOL _create_optional_headers(sce_buffer_ctxt_t *ctxt, self_config_t *sco //Add default flags. if(sconf->cap_flags == NULL) - _set_cap_flags(self_type, capf); + _set_cap_flags(program_type, capf); else memcpy(capf, sconf->cap_flags, 0x20); @@ -899,9 +888,9 @@ static BOOL _create_optional_headers(sce_buffer_ctxt_t *ctxt, self_config_t *sco } //Step 2. - switch(self_type) + switch(program_type) { - case SELF_TYPE_ISO: + case PROGRAM_TYPE_ISO: { //Add individuals seed. oh = (opt_header_t *)malloc(sizeof(opt_header_t) + 0x100); @@ -911,10 +900,8 @@ static BOOL _create_optional_headers(sce_buffer_ctxt_t *ctxt, self_config_t *sco u8 *is = (u8 *)oh + sizeof(opt_header_t); memset(is, 0, 0x100); -#ifdef CONFIG_CUSTOM_INDIV_SEED if(sconf->indiv_seed != NULL) memcpy(is, sconf->indiv_seed, sconf->indiv_seed_size); -#endif list_add_back(ctxt->self.ohs, oh); } @@ -948,7 +935,7 @@ static void _add_phdr_section(sce_buffer_ctxt_t *ctxt, u32 p_type, u32 size, u32 ctxt->self.si[idx].unknown_1 = 0; //Unknown. } -static BOOL _add_shdrs_section(sce_buffer_ctxt_t *ctxt, u32 idx) +static bool _add_shdrs_section(sce_buffer_ctxt_t *ctxt, u32 idx) { //Add a section for the section headers. if(ctxt->makeself->shdrs != NULL) @@ -966,7 +953,7 @@ static BOOL _add_shdrs_section(sce_buffer_ctxt_t *ctxt, u32 idx) return FALSE; } -static BOOL _build_self_32(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) +static bool _build_self_32(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) { u32 i; @@ -1044,7 +1031,7 @@ static BOOL _build_self_32(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) return TRUE; } -static BOOL _build_self_64(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) +static bool _build_self_64(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) { u32 i; @@ -1123,15 +1110,15 @@ static BOOL _build_self_64(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) return TRUE; } -BOOL self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) +bool self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) { const u8 *eident; //Fill config values. - ctxt->sceh->key_revision = _ES16(sconf->key_revision); + ctxt->cfh->key_revision = _ES16(sconf->key_revision); ctxt->self.ai->auth_id = _ES64(sconf->auth_id); ctxt->self.ai->vendor_id = _ES32(sconf->vendor_id); - ctxt->self.ai->self_type = _ES32(sconf->self_type); + ctxt->self.ai->program_type = _ES32(sconf->program_type); ctxt->self.ai->version = _ES64(sconf->app_version); //Create control infos. @@ -1141,10 +1128,8 @@ BOOL self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) return FALSE; } -#ifdef CONFIG_CUSTOM_INDIV_SEED - if(sconf->indiv_seed != NULL && sconf->self_type != SELF_TYPE_ISO) + if(sconf->indiv_seed != NULL && sconf->program_type != PROGRAM_TYPE_ISO) printf("[*] Warning: Skipping individuals seed for non-ISO SELF.\n"); -#endif //Create optional headers. if(_create_optional_headers(ctxt, sconf) == FALSE) @@ -1158,7 +1143,7 @@ BOOL self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf) //Check for 32 bit or 64 bit ELF. eident = (const u8*)ctxt->makeself->elf; - if(sconf->self_type == SELF_TYPE_LDR || sconf->self_type == SELF_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) + if(sconf->program_type == PROGRAM_TYPE_LDR || sconf->program_type == PROGRAM_TYPE_ISO || eident[EI_CLASS] == ELFCLASS32) return _build_self_32(ctxt, sconf); return _build_self_64(ctxt, sconf); } diff --git a/src/self.h b/src/self.h index c4377c8..82841f4 100644 --- a/src/self.h +++ b/src/self.h @@ -26,11 +26,11 @@ typedef struct _self_config { /*! Add section headers. */ - BOOL add_shdrs; + bool add_shdrs; /*! Compress data. */ - BOOL compress_data; + bool compress_data; /*! Skip sections. */ - BOOL skip_sections; + bool skip_sections; /*! Key revision. */ u16 key_revision; @@ -38,35 +38,35 @@ typedef struct _self_config u64 auth_id; /*! Vendor ID. */ u32 vendor_id; - /*! SELF type. */ - u32 self_type; + /*! Program type. */ + u32 program_type; /*! Application version. */ u64 app_version; /*! Firmware version. */ u64 fw_version; - /*! Control flags. */ u8 *ctrl_flags; /*! Capability flags. */ u8 *cap_flags; -#ifdef CONFIG_CUSTOM_INDIV_SEED /*! Individuals seed. */ u8 *indiv_seed; /*! Individuals seed size. */ u32 indiv_seed_size; -#endif /*! NPDRM config (used if not NULL). */ npdrm_config_t *npdrm_config; } self_config_t; /*! Print SELF info. */ -BOOL self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt); +bool self_print_info(FILE *fp, sce_buffer_ctxt_t *ctxt); + +/*! Print SELF encrypted info. */ +bool self_print_encrypted_info(FILE *fp, sce_buffer_ctxt_t *ctxt); /*! Create ELF from SELF. */ -BOOL self_write_to_elf(sce_buffer_ctxt_t *ctxt, const s8 *elf_out); +bool self_write_to_elf(sce_buffer_ctxt_t *ctxt, const s8 *elf_out); /*! Create SELF from ELF. */ -BOOL self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf); +bool self_build_self(sce_buffer_ctxt_t *ctxt, self_config_t *sconf); #endif diff --git a/src/tables.cpp b/src/tables.cpp index f04fb3d..5afe1cb 100644 --- a/src/tables.cpp +++ b/src/tables.cpp @@ -12,30 +12,30 @@ #include "keys.h" /*! SELF types. */ -id_to_name_t _self_types[] = +id_to_name_t _program_types[] = { - {SELF_TYPE_LV0, "lv0"}, - {SELF_TYPE_LV1, "lv1"}, - {SELF_TYPE_LV2, "lv2"}, - {SELF_TYPE_APP, "Application"}, - {SELF_TYPE_ISO, "Isolated SPU Module"}, - {SELF_TYPE_LDR, "Secure Loader"}, - {SELF_TYPE_UNK_7, "Unknown 7"}, - {SELF_TYPE_NPDRM, "NPDRM Application"}, + {PROGRAM_TYPE_LV0, "lv0"}, + {PROGRAM_TYPE_LV1, "lv1"}, + {PROGRAM_TYPE_LV2, "lv2"}, + {PROGRAM_TYPE_APP, "Application"}, + {PROGRAM_TYPE_ISO, "Isolated SPU Module"}, + {PROGRAM_TYPE_LDR, "Secure Loader"}, + {PROGRAM_TYPE_UNK_7, "Unknown 7"}, + {PROGRAM_TYPE_NPDRM, "NPDRM Application"}, {0, NULL} }; /*! SELF types as parameter. */ -id_to_name_t _self_types_params[] = +id_to_name_t _program_types_params[] = { - {SELF_TYPE_LV0, "LV0"}, - {SELF_TYPE_LV1, "LV1"}, - {SELF_TYPE_LV2, "LV2"}, - {SELF_TYPE_APP, "APP"}, - {SELF_TYPE_ISO, "ISO"}, - {SELF_TYPE_LDR, "LDR"}, - //{SELF_TYPE_UNK_7, "UNK7"}, - {SELF_TYPE_NPDRM, "NPDRM"}, + {PROGRAM_TYPE_LV0, "LV0"}, + {PROGRAM_TYPE_LV1, "LV1"}, + {PROGRAM_TYPE_LV2, "LV2"}, + {PROGRAM_TYPE_APP, "APP"}, + {PROGRAM_TYPE_ISO, "ISO"}, + {PROGRAM_TYPE_LDR, "LDR"}, + //{PROGRAM_TYPE_UNK_7, "UNK7"}, + {PROGRAM_TYPE_NPDRM, "NPDRM"}, {0, NULL} }; @@ -52,9 +52,7 @@ id_to_name_t _control_info_types[] = id_to_name_t _optional_header_types[] = { {OPT_HEADER_TYPE_CAP_FLAGS, "Capability Flags"}, -#ifdef CONFIG_DUMP_INDIV_SEED {OPT_HEADER_TYPE_INDIV_SEED, "Individuals Seed"}, -#endif {0, NULL} }; @@ -111,6 +109,8 @@ id_to_name_t _auth_ids[] = {0x1070000041000001, "ps1emu"}, {0x1070000043000001, "me_iso_spu_module"}, {0x1070000046000001, "spu_mode_auth"}, + {0x1070000047000001, "otheros"}, + {0x1070000048000001, "ftpd"}, {0x107000004C000001, "spu_utoken_processor"}, {0x1070000052000001, "sys/internal + vsh/module modules"}, {0x1070000055000001, "manu_info_spu_module"}, @@ -208,13 +208,13 @@ id_to_name_t _ph_types[] = }; /*! Key types. */ -id_to_name_t _key_types[] = +id_to_name_t _key_categories[] = { - {KEYTYPE_SELF, "SELF"}, - {KEYTYPE_RVK, "RVK"}, - {KEYTYPE_PKG, "PKG"}, - {KEYTYPE_SPP, "SPP"}, - {KEYTYPE_OTHER, "OTHER"}, + {KEYCATEGORY_SELF, "SELF"}, + {KEYCATEGORY_RVK, "RVK"}, + {KEYCATEGORY_PKG, "PKG"}, + {KEYCATEGORY_SPP, "SPP"}, + {KEYCATEGORY_OTHER, "OTHER"}, {0, NULL} }; @@ -257,12 +257,18 @@ const s8 *_key_revisions[] = }; */ -/*! SCE header types. */ -id_to_name_t _sce_header_types[] = +/*! Cert file types. */ +id_to_name_t _cert_file_categories[] = { - {SCE_HEADER_TYPE_SELF, "SELF"}, - {SCE_HEADER_TYPE_RVK, "RVK"}, - {SCE_HEADER_TYPE_PKG, "PKG"}, - {SCE_HEADER_TYPE_SPP, "SPP"}, + {CF_CATEGORY_SELF, "SELF"}, + {CF_CATEGORY_RVK, "RVK"}, + {CF_CATEGORY_PKG, "PKG"}, + {CF_CATEGORY_SPP, "SPP"}, + {0, NULL} +}; + +id_to_name_t _sig_algorithms[] = +{ + {SIGNATURE_ALGORITHM_ECDSA, "ECDSA"}, {0, NULL} }; diff --git a/src/tables.h b/src/tables.h index ce65729..3f478b7 100644 --- a/src/tables.h +++ b/src/tables.h @@ -10,10 +10,10 @@ #include "util.h" /*! SELF types. */ -extern id_to_name_t _self_types[]; +extern id_to_name_t _program_types[]; /*! SELF types as parameter. */ -extern id_to_name_t _self_types_params[]; +extern id_to_name_t _program_types_params[]; /* Control info types. */ extern id_to_name_t _control_info_types[]; @@ -46,12 +46,15 @@ extern id_to_name_t _sh_types[]; extern id_to_name_t _ph_types[]; /*! Key types. */ -extern id_to_name_t _key_types[]; +extern id_to_name_t _key_categories[]; /*! Key revisions. */ //extern const s8 *_key_revisions[]; -/*! SCE header types. */ -extern id_to_name_t _sce_header_types[]; +/*! Cert file types. */ +extern id_to_name_t _cert_file_categories[]; + +/*! Signature algorithms. */ +extern id_to_name_t _sig_algorithms[]; #endif diff --git a/src/types.h b/src/types.h index 41a7add..129b9f8 100644 --- a/src/types.h +++ b/src/types.h @@ -23,7 +23,7 @@ typedef long long int s64; typedef unsigned long long int u64; #endif -#define BOOL int +#define bool int #define TRUE 1 #define FALSE 0 diff --git a/src/util.cpp b/src/util.cpp index 5a5733d..2f81f29 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -2,6 +2,7 @@ * Copyright (c) 2011-2013 by naehrwert * This file is released under the GPLv2. */ +#define _CRT_SECURE_NO_WARNINGS #include #include @@ -13,7 +14,7 @@ #include "zlib.h" #include "mt19937.h" -void _hexdump(FILE *fp, const char *name, u32 offset, u8 *buf, int len, BOOL print_addr) +void _hexdump(FILE *fp, const char *name, u32 offset, u8 *buf, int len, bool print_addr) { int i, j, align = strlen(name) + 1; @@ -133,9 +134,9 @@ void _zlib_inflate(u8 *in, u64 len_in, u8 *out, u64 len_out) inflateInit(&s); - s.avail_in = len_in; + s.avail_in = (u32)len_in; s.next_in = in; - s.avail_out = len_out; + s.avail_out = (u32)len_out; s.next_out = out; inflate(&s, Z_FINISH); @@ -154,9 +155,9 @@ void _zlib_deflate(u8 *in, u64 len_in, u8 *out, u64 len_out) deflateInit(&s, Z_BEST_COMPRESSION); - s.avail_in = len_in; + s.avail_in = (u32)len_in; s.next_in = in; - s.avail_out = len_out; + s.avail_out = (u32)len_out; s.next_out = out; deflate(&s, Z_FINISH); @@ -165,7 +166,7 @@ void _zlib_deflate(u8 *in, u64 len_in, u8 *out, u64 len_out) } static mt19937_ctxt_t _mt19937_ctxt; -static BOOL _mt_init = FALSE; +static bool _mt_init = FALSE; u8 _get_rand_byte() { diff --git a/src/util.h b/src/util.h index 42bdc56..834061f 100644 --- a/src/util.h +++ b/src/util.h @@ -11,7 +11,7 @@ #include "types.h" /*! Verbose. */ -extern BOOL _verbose; +extern bool _verbose; #define _LOG_VERBOSE(...) _IF_VERBOSE(printf("[*] " __VA_ARGS__)) #define _IF_VERBOSE(code) \ do \ @@ -23,7 +23,7 @@ extern BOOL _verbose; } while(0) /*! Raw. */ -extern BOOL _raw; +extern bool _raw; #define _PRINT_RAW(fp, ...) _IF_RAW(fprintf(fp, __VA_ARGS__)) #define _IF_RAW(code) \ do \ @@ -42,7 +42,7 @@ typedef struct _id_to_name } id_to_name_t; /*! Utility functions. */ -void _hexdump(FILE *fp, const char *name, u32 offset, u8 *buf, int len, BOOL print_addr); +void _hexdump(FILE *fp, const char *name, u32 offset, u8 *buf, int len, bool print_addr); void _print_align(FILE *fp, const s8 *str, s32 align, s32 len); u8 *_read_buffer(const s8 *file, u32 *length); int _write_buffer(const s8 *file, u8 *buffer, u32 length); diff --git a/zlib/src/CMakeLists.txt b/zlib/src/CMakeLists.txt new file mode 100644 index 0000000..0c0247c --- /dev/null +++ b/zlib/src/CMakeLists.txt @@ -0,0 +1,249 @@ +cmake_minimum_required(VERSION 2.4.4) +set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON) + +project(zlib C) + +set(VERSION "1.2.8") + +option(ASM686 "Enable building i686 assembly implementation") +option(AMD64 "Enable building amd64 assembly implementation") + +set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables") +set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries") +set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers") +set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages") +set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files") + +include(CheckTypeSize) +include(CheckFunctionExists) +include(CheckIncludeFile) +include(CheckCSourceCompiles) +enable_testing() + +check_include_file(sys/types.h HAVE_SYS_TYPES_H) +check_include_file(stdint.h HAVE_STDINT_H) +check_include_file(stddef.h HAVE_STDDEF_H) + +# +# Check to see if we have large file support +# +set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1) +# We add these other definitions here because CheckTypeSize.cmake +# in CMake 2.4.x does not automatically do so and we want +# compatibility with CMake 2.4.x. +if(HAVE_SYS_TYPES_H) + list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H) +endif() +if(HAVE_STDINT_H) + list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H) +endif() +if(HAVE_STDDEF_H) + list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H) +endif() +check_type_size(off64_t OFF64_T) +if(HAVE_OFF64_T) + add_definitions(-D_LARGEFILE64_SOURCE=1) +endif() +set(CMAKE_REQUIRED_DEFINITIONS) # clear variable + +# +# Check for fseeko +# +check_function_exists(fseeko HAVE_FSEEKO) +if(NOT HAVE_FSEEKO) + add_definitions(-DNO_FSEEKO) +endif() + +# +# Check for unistd.h +# +check_include_file(unistd.h Z_HAVE_UNISTD_H) + +if(MSVC) + set(CMAKE_DEBUG_POSTFIX "d") + add_definitions(-D_CRT_SECURE_NO_DEPRECATE) + add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}) +endif() + +if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR) + # If we're doing an out of source build and the user has a zconf.h + # in their source tree... + if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h) + message(STATUS "Renaming") + message(STATUS " ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h") + message(STATUS "to 'zconf.h.included' because this file is included with zlib") + message(STATUS "but CMake generates it automatically in the build directory.") + file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.included) + endif() +endif() + +set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc) +configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein + ${ZLIB_PC} @ONLY) +configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein + ${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY) +include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR}) + + +#============================================================================ +# zlib +#============================================================================ + +set(ZLIB_PUBLIC_HDRS + ${CMAKE_CURRENT_BINARY_DIR}/zconf.h + zlib.h +) +set(ZLIB_PRIVATE_HDRS + crc32.h + deflate.h + gzguts.h + inffast.h + inffixed.h + inflate.h + inftrees.h + trees.h + zutil.h +) +set(ZLIB_SRCS + adler32.c + compress.c + crc32.c + deflate.c + gzclose.c + gzlib.c + gzread.c + gzwrite.c + inflate.c + infback.c + inftrees.c + inffast.c + trees.c + uncompr.c + zutil.c +) + +if(NOT MINGW) + set(ZLIB_DLL_SRCS + win32/zlib1.rc # If present will override custom build rule below. + ) +endif() + +if(CMAKE_COMPILER_IS_GNUCC) + if(ASM686) + set(ZLIB_ASMS contrib/asm686/match.S) + elseif (AMD64) + set(ZLIB_ASMS contrib/amd64/amd64-match.S) + endif () + + if(ZLIB_ASMS) + add_definitions(-DASMV) + set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE) + endif() +endif() + +if(MSVC) + if(ASM686) + ENABLE_LANGUAGE(ASM_MASM) + set(ZLIB_ASMS + contrib/masmx86/inffas32.asm + contrib/masmx86/match686.asm + ) + elseif (AMD64) + ENABLE_LANGUAGE(ASM_MASM) + set(ZLIB_ASMS + contrib/masmx64/gvmat64.asm + contrib/masmx64/inffasx64.asm + ) + endif() + + if(ZLIB_ASMS) + add_definitions(-DASMV -DASMINF) + endif() +endif() + +# parse the full version number from zlib.h and include in ZLIB_FULL_VERSION +file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents) +string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*" + "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents}) + +if(MINGW) + # This gets us DLL resource information when compiling on MinGW. + if(NOT CMAKE_RC_COMPILER) + set(CMAKE_RC_COMPILER windres.exe) + endif() + + add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj + COMMAND ${CMAKE_RC_COMPILER} + -D GCC_WINDRES + -I ${CMAKE_CURRENT_SOURCE_DIR} + -I ${CMAKE_CURRENT_BINARY_DIR} + -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj + -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc) + set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj) +endif(MINGW) + +add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) +add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) +set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL) +set_target_properties(zlib PROPERTIES SOVERSION 1) + +if(NOT CYGWIN) + # This property causes shared libraries on Linux to have the full version + # encoded into their final filename. We disable this on Cygwin because + # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll + # seems to be the default. + # + # This has no effect with MSVC, on that platform the version info for + # the DLL comes from the resource file win32/zlib1.rc + set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION}) +endif() + +if(UNIX) + # On unix-like platforms the library is almost always called libz + set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z) + if(NOT APPLE) + set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"") + endif() +elseif(BUILD_SHARED_LIBS AND WIN32) + # Creates zlib1.dll when building shared library version + set_target_properties(zlib PROPERTIES SUFFIX "1.dll") +endif() + +if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL ) + install(TARGETS zlib zlibstatic + RUNTIME DESTINATION "${INSTALL_BIN_DIR}" + ARCHIVE DESTINATION "${INSTALL_LIB_DIR}" + LIBRARY DESTINATION "${INSTALL_LIB_DIR}" ) +endif() +if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL ) + install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}") +endif() +if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL ) + install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3") +endif() +if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL ) + install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}") +endif() + +#============================================================================ +# Example binaries +#============================================================================ + +add_executable(example test/example.c) +target_link_libraries(example zlib) +add_test(example example) + +add_executable(minigzip test/minigzip.c) +target_link_libraries(minigzip zlib) + +if(HAVE_OFF64_T) + add_executable(example64 test/example.c) + target_link_libraries(example64 zlib) + set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") + add_test(example64 example64) + + add_executable(minigzip64 test/minigzip.c) + target_link_libraries(minigzip64 zlib) + set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") +endif() diff --git a/zlib/src/ChangeLog b/zlib/src/ChangeLog new file mode 100644 index 0000000..f22aaba --- /dev/null +++ b/zlib/src/ChangeLog @@ -0,0 +1,1472 @@ + + ChangeLog file for zlib + +Changes in 1.2.8 (28 Apr 2013) +- Update contrib/minizip/iowin32.c for Windows RT [Vollant] +- Do not force Z_CONST for C++ +- Clean up contrib/vstudio [Ro§] +- Correct spelling error in zlib.h +- Fix mixed line endings in contrib/vstudio + +Changes in 1.2.7.3 (13 Apr 2013) +- Fix version numbers and DLL names in contrib/vstudio/*/zlib.rc + +Changes in 1.2.7.2 (13 Apr 2013) +- Change check for a four-byte type back to hexadecimal +- Fix typo in win32/Makefile.msc +- Add casts in gzwrite.c for pointer differences + +Changes in 1.2.7.1 (24 Mar 2013) +- Replace use of unsafe string functions with snprintf if available +- Avoid including stddef.h on Windows for Z_SOLO compile [Niessink] +- Fix gzgetc undefine when Z_PREFIX set [Turk] +- Eliminate use of mktemp in Makefile (not always available) +- Fix bug in 'F' mode for gzopen() +- Add inflateGetDictionary() function +- Correct comment in deflate.h +- Use _snprintf for snprintf in Microsoft C +- On Darwin, only use /usr/bin/libtool if libtool is not Apple +- Delete "--version" file if created by "ar --version" [Richard G.] +- Fix configure check for veracity of compiler error return codes +- Fix CMake compilation of static lib for MSVC2010 x64 +- Remove unused variable in infback9.c +- Fix argument checks in gzlog_compress() and gzlog_write() +- Clean up the usage of z_const and respect const usage within zlib +- Clean up examples/gzlog.[ch] comparisons of different types +- Avoid shift equal to bits in type (caused endless loop) +- Fix unintialized value bug in gzputc() introduced by const patches +- Fix memory allocation error in examples/zran.c [Nor] +- Fix bug where gzopen(), gzclose() would write an empty file +- Fix bug in gzclose() when gzwrite() runs out of memory +- Check for input buffer malloc failure in examples/gzappend.c +- Add note to contrib/blast to use binary mode in stdio +- Fix comparisons of differently signed integers in contrib/blast +- Check for invalid code length codes in contrib/puff +- Fix serious but very rare decompression bug in inftrees.c +- Update inflateBack() comments, since inflate() can be faster +- Use underscored I/O function names for WINAPI_FAMILY +- Add _tr_flush_bits to the external symbols prefixed by --zprefix +- Add contrib/vstudio/vc10 pre-build step for static only +- Quote --version-script argument in CMakeLists.txt +- Don't specify --version-script on Apple platforms in CMakeLists.txt +- Fix casting error in contrib/testzlib/testzlib.c +- Fix types in contrib/minizip to match result of get_crc_table() +- Simplify contrib/vstudio/vc10 with 'd' suffix +- Add TOP support to win32/Makefile.msc +- Suport i686 and amd64 assembler builds in CMakeLists.txt +- Fix typos in the use of _LARGEFILE64_SOURCE in zconf.h +- Add vc11 and vc12 build files to contrib/vstudio +- Add gzvprintf() as an undocumented function in zlib +- Fix configure for Sun shell +- Remove runtime check in configure for four-byte integer type +- Add casts and consts to ease user conversion to C++ +- Add man pages for minizip and miniunzip +- In Makefile uninstall, don't rm if preceding cd fails +- Do not return Z_BUF_ERROR if deflateParam() has nothing to write + +Changes in 1.2.7 (2 May 2012) +- Replace use of memmove() with a simple copy for portability +- Test for existence of strerror +- Restore gzgetc_ for backward compatibility with 1.2.6 +- Fix build with non-GNU make on Solaris +- Require gcc 4.0 or later on Mac OS X to use the hidden attribute +- Include unistd.h for Watcom C +- Use __WATCOMC__ instead of __WATCOM__ +- Do not use the visibility attribute if NO_VIZ defined +- Improve the detection of no hidden visibility attribute +- Avoid using __int64 for gcc or solo compilation +- Cast to char * in gzprintf to avoid warnings [Zinser] +- Fix make_vms.com for VAX [Zinser] +- Don't use library or built-in byte swaps +- Simplify test and use of gcc hidden attribute +- Fix bug in gzclose_w() when gzwrite() fails to allocate memory +- Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen() +- Fix bug in test/minigzip.c for configure --solo +- Fix contrib/vstudio project link errors [Mohanathas] +- Add ability to choose the builder in make_vms.com [Schweda] +- Add DESTDIR support to mingw32 win32/Makefile.gcc +- Fix comments in win32/Makefile.gcc for proper usage +- Allow overriding the default install locations for cmake +- Generate and install the pkg-config file with cmake +- Build both a static and a shared version of zlib with cmake +- Include version symbols for cmake builds +- If using cmake with MSVC, add the source directory to the includes +- Remove unneeded EXTRA_CFLAGS from win32/Makefile.gcc [Truta] +- Move obsolete emx makefile to old [Truta] +- Allow the use of -Wundef when compiling or using zlib +- Avoid the use of the -u option with mktemp +- Improve inflate() documentation on the use of Z_FINISH +- Recognize clang as gcc +- Add gzopen_w() in Windows for wide character path names +- Rename zconf.h in CMakeLists.txt to move it out of the way +- Add source directory in CMakeLists.txt for building examples +- Look in build directory for zlib.pc in CMakeLists.txt +- Remove gzflags from zlibvc.def in vc9 and vc10 +- Fix contrib/minizip compilation in the MinGW environment +- Update ./configure for Solaris, support --64 [Mooney] +- Remove -R. from Solaris shared build (possible security issue) +- Avoid race condition for parallel make (-j) running example +- Fix type mismatch between get_crc_table() and crc_table +- Fix parsing of version with "-" in CMakeLists.txt [Snider, Ziegler] +- Fix the path to zlib.map in CMakeLists.txt +- Force the native libtool in Mac OS X to avoid GNU libtool [Beebe] +- Add instructions to win32/Makefile.gcc for shared install [Torri] + +Changes in 1.2.6.1 (12 Feb 2012) +- Avoid the use of the Objective-C reserved name "id" +- Include io.h in gzguts.h for Microsoft compilers +- Fix problem with ./configure --prefix and gzgetc macro +- Include gz_header definition when compiling zlib solo +- Put gzflags() functionality back in zutil.c +- Avoid library header include in crc32.c for Z_SOLO +- Use name in GCC_CLASSIC as C compiler for coverage testing, if set +- Minor cleanup in contrib/minizip/zip.c [Vollant] +- Update make_vms.com [Zinser] +- Remove unnecessary gzgetc_ function +- Use optimized byte swap operations for Microsoft and GNU [Snyder] +- Fix minor typo in zlib.h comments [Rzesniowiecki] + +Changes in 1.2.6 (29 Jan 2012) +- Update the Pascal interface in contrib/pascal +- Fix function numbers for gzgetc_ in zlibvc.def files +- Fix configure.ac for contrib/minizip [Schiffer] +- Fix large-entry detection in minizip on 64-bit systems [Schiffer] +- Have ./configure use the compiler return code for error indication +- Fix CMakeLists.txt for cross compilation [McClure] +- Fix contrib/minizip/zip.c for 64-bit architectures [Dalsnes] +- Fix compilation of contrib/minizip on FreeBSD [Marquez] +- Correct suggested usages in win32/Makefile.msc [Shachar, Horvath] +- Include io.h for Turbo C / Borland C on all platforms [Truta] +- Make version explicit in contrib/minizip/configure.ac [Bosmans] +- Avoid warning for no encryption in contrib/minizip/zip.c [Vollant] +- Minor cleanup up contrib/minizip/unzip.c [Vollant] +- Fix bug when compiling minizip with C++ [Vollant] +- Protect for long name and extra fields in contrib/minizip [Vollant] +- Avoid some warnings in contrib/minizip [Vollant] +- Add -I../.. -L../.. to CFLAGS for minizip and miniunzip +- Add missing libs to minizip linker command +- Add support for VPATH builds in contrib/minizip +- Add an --enable-demos option to contrib/minizip/configure +- Add the generation of configure.log by ./configure +- Exit when required parameters not provided to win32/Makefile.gcc +- Have gzputc return the character written instead of the argument +- Use the -m option on ldconfig for BSD systems [Tobias] +- Correct in zlib.map when deflateResetKeep was added + +Changes in 1.2.5.3 (15 Jan 2012) +- Restore gzgetc function for binary compatibility +- Do not use _lseeki64 under Borland C++ [Truta] +- Update win32/Makefile.msc to build test/*.c [Truta] +- Remove old/visualc6 given CMakefile and other alternatives +- Update AS400 build files and documentation [Monnerat] +- Update win32/Makefile.gcc to build test/*.c [Truta] +- Permit stronger flushes after Z_BLOCK flushes +- Avoid extraneous empty blocks when doing empty flushes +- Permit Z_NULL arguments to deflatePending +- Allow deflatePrime() to insert bits in the middle of a stream +- Remove second empty static block for Z_PARTIAL_FLUSH +- Write out all of the available bits when using Z_BLOCK +- Insert the first two strings in the hash table after a flush + +Changes in 1.2.5.2 (17 Dec 2011) +- fix ld error: unable to find version dependency 'ZLIB_1.2.5' +- use relative symlinks for shared libs +- Avoid searching past window for Z_RLE strategy +- Assure that high-water mark initialization is always applied in deflate +- Add assertions to fill_window() in deflate.c to match comments +- Update python link in README +- Correct spelling error in gzread.c +- Fix bug in gzgets() for a concatenated empty gzip stream +- Correct error in comment for gz_make() +- Change gzread() and related to ignore junk after gzip streams +- Allow gzread() and related to continue after gzclearerr() +- Allow gzrewind() and gzseek() after a premature end-of-file +- Simplify gzseek() now that raw after gzip is ignored +- Change gzgetc() to a macro for speed (~40% speedup in testing) +- Fix gzclose() to return the actual error last encountered +- Always add large file support for windows +- Include zconf.h for windows large file support +- Include zconf.h.cmakein for windows large file support +- Update zconf.h.cmakein on make distclean +- Merge vestigial vsnprintf determination from zutil.h to gzguts.h +- Clarify how gzopen() appends in zlib.h comments +- Correct documentation of gzdirect() since junk at end now ignored +- Add a transparent write mode to gzopen() when 'T' is in the mode +- Update python link in zlib man page +- Get inffixed.h and MAKEFIXED result to match +- Add a ./config --solo option to make zlib subset with no libary use +- Add undocumented inflateResetKeep() function for CAB file decoding +- Add --cover option to ./configure for gcc coverage testing +- Add #define ZLIB_CONST option to use const in the z_stream interface +- Add comment to gzdopen() in zlib.h to use dup() when using fileno() +- Note behavior of uncompress() to provide as much data as it can +- Add files in contrib/minizip to aid in building libminizip +- Split off AR options in Makefile.in and configure +- Change ON macro to Z_ARG to avoid application conflicts +- Facilitate compilation with Borland C++ for pragmas and vsnprintf +- Include io.h for Turbo C / Borland C++ +- Move example.c and minigzip.c to test/ +- Simplify incomplete code table filling in inflate_table() +- Remove code from inflate.c and infback.c that is impossible to execute +- Test the inflate code with full coverage +- Allow deflateSetDictionary, inflateSetDictionary at any time (in raw) +- Add deflateResetKeep and fix inflateResetKeep to retain dictionary +- Fix gzwrite.c to accommodate reduced memory zlib compilation +- Have inflate() with Z_FINISH avoid the allocation of a window +- Do not set strm->adler when doing raw inflate +- Fix gzeof() to behave just like feof() when read is not past end of file +- Fix bug in gzread.c when end-of-file is reached +- Avoid use of Z_BUF_ERROR in gz* functions except for premature EOF +- Document gzread() capability to read concurrently written files +- Remove hard-coding of resource compiler in CMakeLists.txt [Blammo] + +Changes in 1.2.5.1 (10 Sep 2011) +- Update FAQ entry on shared builds (#13) +- Avoid symbolic argument to chmod in Makefile.in +- Fix bug and add consts in contrib/puff [Oberhumer] +- Update contrib/puff/zeros.raw test file to have all block types +- Add full coverage test for puff in contrib/puff/Makefile +- Fix static-only-build install in Makefile.in +- Fix bug in unzGetCurrentFileInfo() in contrib/minizip [Kuno] +- Add libz.a dependency to shared in Makefile.in for parallel builds +- Spell out "number" (instead of "nb") in zlib.h for total_in, total_out +- Replace $(...) with `...` in configure for non-bash sh [Bowler] +- Add darwin* to Darwin* and solaris* to SunOS\ 5* in configure [Groffen] +- Add solaris* to Linux* in configure to allow gcc use [Groffen] +- Add *bsd* to Linux* case in configure [Bar-Lev] +- Add inffast.obj to dependencies in win32/Makefile.msc +- Correct spelling error in deflate.h [Kohler] +- Change libzdll.a again to libz.dll.a (!) in win32/Makefile.gcc +- Add test to configure for GNU C looking for gcc in output of $cc -v +- Add zlib.pc generation to win32/Makefile.gcc [Weigelt] +- Fix bug in zlib.h for _FILE_OFFSET_BITS set and _LARGEFILE64_SOURCE not +- Add comment in zlib.h that adler32_combine with len2 < 0 makes no sense +- Make NO_DIVIDE option in adler32.c much faster (thanks to John Reiser) +- Make stronger test in zconf.h to include unistd.h for LFS +- Apply Darwin patches for 64-bit file offsets to contrib/minizip [Slack] +- Fix zlib.h LFS support when Z_PREFIX used +- Add updated as400 support (removed from old) [Monnerat] +- Avoid deflate sensitivity to volatile input data +- Avoid division in adler32_combine for NO_DIVIDE +- Clarify the use of Z_FINISH with deflateBound() amount of space +- Set binary for output file in puff.c +- Use u4 type for crc_table to avoid conversion warnings +- Apply casts in zlib.h to avoid conversion warnings +- Add OF to prototypes for adler32_combine_ and crc32_combine_ [Miller] +- Improve inflateSync() documentation to note indeterminancy +- Add deflatePending() function to return the amount of pending output +- Correct the spelling of "specification" in FAQ [Randers-Pehrson] +- Add a check in configure for stdarg.h, use for gzprintf() +- Check that pointers fit in ints when gzprint() compiled old style +- Add dummy name before $(SHAREDLIBV) in Makefile [Bar-Lev, Bowler] +- Delete line in configure that adds -L. libz.a to LDFLAGS [Weigelt] +- Add debug records in assmebler code [Londer] +- Update RFC references to use http://tools.ietf.org/html/... [Li] +- Add --archs option, use of libtool to configure for Mac OS X [Borstel] + +Changes in 1.2.5 (19 Apr 2010) +- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev] +- Default to libdir as sharedlibdir in configure [Nieder] +- Update copyright dates on modified source files +- Update trees.c to be able to generate modified trees.h +- Exit configure for MinGW, suggesting win32/Makefile.gcc +- Check for NULL path in gz_open [Homurlu] + +Changes in 1.2.4.5 (18 Apr 2010) +- Set sharedlibdir in configure [Torok] +- Set LDFLAGS in Makefile.in [Bar-Lev] +- Avoid mkdir objs race condition in Makefile.in [Bowler] +- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays +- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C +- Don't use hidden attribute when it is a warning generator (e.g. Solaris) + +Changes in 1.2.4.4 (18 Apr 2010) +- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok] +- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty +- Try to use bash or ksh regardless of functionality of /bin/sh +- Fix configure incompatibility with NetBSD sh +- Remove attempt to run under bash or ksh since have better NetBSD fix +- Fix win32/Makefile.gcc for MinGW [Bar-Lev] +- Add diagnostic messages when using CROSS_PREFIX in configure +- Added --sharedlibdir option to configure [Weigelt] +- Use hidden visibility attribute when available [Frysinger] + +Changes in 1.2.4.3 (10 Apr 2010) +- Only use CROSS_PREFIX in configure for ar and ranlib if they exist +- Use CROSS_PREFIX for nm [Bar-Lev] +- Assume _LARGEFILE64_SOURCE defined is equivalent to true +- Avoid use of undefined symbols in #if with && and || +- Make *64 prototypes in gzguts.h consistent with functions +- Add -shared load option for MinGW in configure [Bowler] +- Move z_off64_t to public interface, use instead of off64_t +- Remove ! from shell test in configure (not portable to Solaris) +- Change +0 macro tests to -0 for possibly increased portability + +Changes in 1.2.4.2 (9 Apr 2010) +- Add consistent carriage returns to readme.txt's in masmx86 and masmx64 +- Really provide prototypes for *64 functions when building without LFS +- Only define unlink() in minigzip.c if unistd.h not included +- Update README to point to contrib/vstudio project files +- Move projects/vc6 to old/ and remove projects/ +- Include stdlib.h in minigzip.c for setmode() definition under WinCE +- Clean up assembler builds in win32/Makefile.msc [Rowe] +- Include sys/types.h for Microsoft for off_t definition +- Fix memory leak on error in gz_open() +- Symbolize nm as $NM in configure [Weigelt] +- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt] +- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined +- Fix bug in gzeof() to take into account unused input data +- Avoid initialization of structures with variables in puff.c +- Updated win32/README-WIN32.txt [Rowe] + +Changes in 1.2.4.1 (28 Mar 2010) +- Remove the use of [a-z] constructs for sed in configure [gentoo 310225] +- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech] +- Restore "for debugging" comment on sprintf() in gzlib.c +- Remove fdopen for MVS from gzguts.h +- Put new README-WIN32.txt in win32 [Rowe] +- Add check for shell to configure and invoke another shell if needed +- Fix big fat stinking bug in gzseek() on uncompressed files +- Remove vestigial F_OPEN64 define in zutil.h +- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE +- Avoid errors on non-LFS systems when applications define LFS macros +- Set EXE to ".exe" in configure for MINGW [Kahle] +- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill] +- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev] +- Add DLL install in win32/makefile.gcc [Bar-Lev] +- Allow Linux* or linux* from uname in configure [Bar-Lev] +- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev] +- Add cross-compilation prefixes to configure [Bar-Lev] +- Match type exactly in gz_load() invocation in gzread.c +- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func +- Provide prototypes for *64 functions when building zlib without LFS +- Don't use -lc when linking shared library on MinGW +- Remove errno.h check in configure and vestigial errno code in zutil.h + +Changes in 1.2.4 (14 Mar 2010) +- Fix VER3 extraction in configure for no fourth subversion +- Update zlib.3, add docs to Makefile.in to make .pdf out of it +- Add zlib.3.pdf to distribution +- Don't set error code in gzerror() if passed pointer is NULL +- Apply destination directory fixes to CMakeLists.txt [Lowman] +- Move #cmakedefine's to a new zconf.in.cmakein +- Restore zconf.h for builds that don't use configure or cmake +- Add distclean to dummy Makefile for convenience +- Update and improve INDEX, README, and FAQ +- Update CMakeLists.txt for the return of zconf.h [Lowman] +- Update contrib/vstudio/vc9 and vc10 [Vollant] +- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc +- Apply license and readme changes to contrib/asm686 [Raiter] +- Check file name lengths and add -c option in minigzip.c [Li] +- Update contrib/amd64 and contrib/masmx86/ [Vollant] +- Avoid use of "eof" parameter in trees.c to not shadow library variable +- Update make_vms.com for removal of zlibdefs.h [Zinser] +- Update assembler code and vstudio projects in contrib [Vollant] +- Remove outdated assembler code contrib/masm686 and contrib/asm586 +- Remove old vc7 and vc8 from contrib/vstudio +- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe] +- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open() +- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant] +- Remove *64 functions from win32/zlib.def (they're not 64-bit yet) +- Fix bug in void-returning vsprintf() case in gzwrite.c +- Fix name change from inflate.h in contrib/inflate86/inffas86.c +- Check if temporary file exists before removing in make_vms.com [Zinser] +- Fix make install and uninstall for --static option +- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta] +- Update readme.txt in contrib/masmx64 and masmx86 to assemble + +Changes in 1.2.3.9 (21 Feb 2010) +- Expunge gzio.c +- Move as400 build information to old +- Fix updates in contrib/minizip and contrib/vstudio +- Add const to vsnprintf test in configure to avoid warnings [Weigelt] +- Delete zconf.h (made by configure) [Weigelt] +- Change zconf.in.h to zconf.h.in per convention [Weigelt] +- Check for NULL buf in gzgets() +- Return empty string for gzgets() with len == 1 (like fgets()) +- Fix description of gzgets() in zlib.h for end-of-file, NULL return +- Update minizip to 1.1 [Vollant] +- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c +- Note in zlib.h that gzerror() should be used to distinguish from EOF +- Remove use of snprintf() from gzlib.c +- Fix bug in gzseek() +- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant] +- Fix zconf.h generation in CMakeLists.txt [Lowman] +- Improve comments in zconf.h where modified by configure + +Changes in 1.2.3.8 (13 Feb 2010) +- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer] +- Use z_off64_t in gz_zero() and gz_skip() to match state->skip +- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t) +- Revert to Makefile.in from 1.2.3.6 (live with the clutter) +- Fix missing error return in gzflush(), add zlib.h note +- Add *64 functions to zlib.map [Levin] +- Fix signed/unsigned comparison in gz_comp() +- Use SFLAGS when testing shared linking in configure +- Add --64 option to ./configure to use -m64 with gcc +- Fix ./configure --help to correctly name options +- Have make fail if a test fails [Levin] +- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson] +- Remove assembler object files from contrib + +Changes in 1.2.3.7 (24 Jan 2010) +- Always gzopen() with O_LARGEFILE if available +- Fix gzdirect() to work immediately after gzopen() or gzdopen() +- Make gzdirect() more precise when the state changes while reading +- Improve zlib.h documentation in many places +- Catch memory allocation failure in gz_open() +- Complete close operation if seek forward in gzclose_w() fails +- Return Z_ERRNO from gzclose_r() if close() fails +- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL +- Return zero for gzwrite() errors to match zlib.h description +- Return -1 on gzputs() error to match zlib.h description +- Add zconf.in.h to allow recovery from configure modification [Weigelt] +- Fix static library permissions in Makefile.in [Weigelt] +- Avoid warnings in configure tests that hide functionality [Weigelt] +- Add *BSD and DragonFly to Linux case in configure [gentoo 123571] +- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212] +- Avoid access of uninitialized data for first inflateReset2 call [Gomes] +- Keep object files in subdirectories to reduce the clutter somewhat +- Remove default Makefile and zlibdefs.h, add dummy Makefile +- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_ +- Remove zlibdefs.h completely -- modify zconf.h instead + +Changes in 1.2.3.6 (17 Jan 2010) +- Avoid void * arithmetic in gzread.c and gzwrite.c +- Make compilers happier with const char * for gz_error message +- Avoid unused parameter warning in inflate.c +- Avoid signed-unsigned comparison warning in inflate.c +- Indent #pragma's for traditional C +- Fix usage of strwinerror() in glib.c, change to gz_strwinerror() +- Correct email address in configure for system options +- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser] +- Update zlib.map [Brown] +- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok] +- Apply various fixes to CMakeLists.txt [Lowman] +- Add checks on len in gzread() and gzwrite() +- Add error message for no more room for gzungetc() +- Remove zlib version check in gzwrite() +- Defer compression of gzprintf() result until need to +- Use snprintf() in gzdopen() if available +- Remove USE_MMAP configuration determination (only used by minigzip) +- Remove examples/pigz.c (available separately) +- Update examples/gun.c to 1.6 + +Changes in 1.2.3.5 (8 Jan 2010) +- Add space after #if in zutil.h for some compilers +- Fix relatively harmless bug in deflate_fast() [Exarevsky] +- Fix same problem in deflate_slow() +- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown] +- Add deflate_rle() for faster Z_RLE strategy run-length encoding +- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding +- Change name of "write" variable in inffast.c to avoid library collisions +- Fix premature EOF from gzread() in gzio.c [Brown] +- Use zlib header window size if windowBits is 0 in inflateInit2() +- Remove compressBound() call in deflate.c to avoid linking compress.o +- Replace use of errno in gz* with functions, support WinCE [Alves] +- Provide alternative to perror() in minigzip.c for WinCE [Alves] +- Don't use _vsnprintf on later versions of MSVC [Lowman] +- Add CMake build script and input file [Lowman] +- Update contrib/minizip to 1.1 [Svensson, Vollant] +- Moved nintendods directory from contrib to . +- Replace gzio.c with a new set of routines with the same functionality +- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above +- Update contrib/minizip to 1.1b +- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h + +Changes in 1.2.3.4 (21 Dec 2009) +- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility +- Update comments in configure and Makefile.in for default --shared +- Fix test -z's in configure [Marquess] +- Build examplesh and minigzipsh when not testing +- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h +- Import LDFLAGS from the environment in configure +- Fix configure to populate SFLAGS with discovered CFLAGS options +- Adapt make_vms.com to the new Makefile.in [Zinser] +- Add zlib2ansi script for C++ compilation [Marquess] +- Add _FILE_OFFSET_BITS=64 test to make test (when applicable) +- Add AMD64 assembler code for longest match to contrib [Teterin] +- Include options from $SFLAGS when doing $LDSHARED +- Simplify 64-bit file support by introducing z_off64_t type +- Make shared object files in objs directory to work around old Sun cc +- Use only three-part version number for Darwin shared compiles +- Add rc option to ar in Makefile.in for when ./configure not run +- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4* +- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile +- Protect against _FILE_OFFSET_BITS being defined when compiling zlib +- Rename Makefile.in targets allstatic to static and allshared to shared +- Fix static and shared Makefile.in targets to be independent +- Correct error return bug in gz_open() by setting state [Brown] +- Put spaces before ;;'s in configure for better sh compatibility +- Add pigz.c (parallel implementation of gzip) to examples/ +- Correct constant in crc32.c to UL [Leventhal] +- Reject negative lengths in crc32_combine() +- Add inflateReset2() function to work like inflateEnd()/inflateInit2() +- Include sys/types.h for _LARGEFILE64_SOURCE [Brown] +- Correct typo in doc/algorithm.txt [Janik] +- Fix bug in adler32_combine() [Zhu] +- Catch missing-end-of-block-code error in all inflates and in puff + Assures that random input to inflate eventually results in an error +- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/ +- Update ENOUGH and its usage to reflect discovered bounds +- Fix gzerror() error report on empty input file [Brown] +- Add ush casts in trees.c to avoid pedantic runtime errors +- Fix typo in zlib.h uncompress() description [Reiss] +- Correct inflate() comments with regard to automatic header detection +- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays) +- Put new version of gzlog (2.0) in examples with interruption recovery +- Add puff compile option to permit invalid distance-too-far streams +- Add puff TEST command options, ability to read piped input +- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but + _LARGEFILE64_SOURCE not defined +- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart +- Fix deflateSetDictionary() to use all 32K for output consistency +- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h) +- Clear bytes after deflate lookahead to avoid use of uninitialized data +- Change a limit in inftrees.c to be more transparent to Coverity Prevent +- Update win32/zlib.def with exported symbols from zlib.h +- Correct spelling errors in zlib.h [Willem, Sobrado] +- Allow Z_BLOCK for deflate() to force a new block +- Allow negative bits in inflatePrime() to delete existing bit buffer +- Add Z_TREES flush option to inflate() to return at end of trees +- Add inflateMark() to return current state information for random access +- Add Makefile for NintendoDS to contrib [Costa] +- Add -w in configure compile tests to avoid spurious warnings [Beucler] +- Fix typos in zlib.h comments for deflateSetDictionary() +- Fix EOF detection in transparent gzread() [Maier] + +Changes in 1.2.3.3 (2 October 2006) +- Make --shared the default for configure, add a --static option +- Add compile option to permit invalid distance-too-far streams +- Add inflateUndermine() function which is required to enable above +- Remove use of "this" variable name for C++ compatibility [Marquess] +- Add testing of shared library in make test, if shared library built +- Use ftello() and fseeko() if available instead of ftell() and fseek() +- Provide two versions of all functions that use the z_off_t type for + binary compatibility -- a normal version and a 64-bit offset version, + per the Large File Support Extension when _LARGEFILE64_SOURCE is + defined; use the 64-bit versions by default when _FILE_OFFSET_BITS + is defined to be 64 +- Add a --uname= option to configure to perhaps help with cross-compiling + +Changes in 1.2.3.2 (3 September 2006) +- Turn off silly Borland warnings [Hay] +- Use off64_t and define _LARGEFILE64_SOURCE when present +- Fix missing dependency on inffixed.h in Makefile.in +- Rig configure --shared to build both shared and static [Teredesai, Truta] +- Remove zconf.in.h and instead create a new zlibdefs.h file +- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant] +- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt] + +Changes in 1.2.3.1 (16 August 2006) +- Add watcom directory with OpenWatcom make files [Daniel] +- Remove #undef of FAR in zconf.in.h for MVS [Fedtke] +- Update make_vms.com [Zinser] +- Use -fPIC for shared build in configure [Teredesai, Nicholson] +- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen] +- Use fdopen() (not _fdopen()) for Interix in zutil.h [BŠck] +- Add some FAQ entries about the contrib directory +- Update the MVS question in the FAQ +- Avoid extraneous reads after EOF in gzio.c [Brown] +- Correct spelling of "successfully" in gzio.c [Randers-Pehrson] +- Add comments to zlib.h about gzerror() usage [Brown] +- Set extra flags in gzip header in gzopen() like deflate() does +- Make configure options more compatible with double-dash conventions + [Weigelt] +- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen] +- Fix uninstall target in Makefile.in [Truta] +- Add pkgconfig support [Weigelt] +- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt] +- Replace set_data_type() with a more accurate detect_data_type() in + trees.c, according to the txtvsbin.txt document [Truta] +- Swap the order of #include and #include "zlib.h" in + gzio.c, example.c and minigzip.c [Truta] +- Shut up annoying VS2005 warnings about standard C deprecation [Rowe, + Truta] (where?) +- Fix target "clean" from win32/Makefile.bor [Truta] +- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe] +- Update zlib www home address in win32/DLL_FAQ.txt [Truta] +- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove] +- Enable browse info in the "Debug" and "ASM Debug" configurations in + the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta] +- Add pkgconfig support [Weigelt] +- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h, + for use in win32/zlib1.rc [Polushin, Rowe, Truta] +- Add a document that explains the new text detection scheme to + doc/txtvsbin.txt [Truta] +- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta] +- Move algorithm.txt into doc/ [Truta] +- Synchronize FAQ with website +- Fix compressBound(), was low for some pathological cases [Fearnley] +- Take into account wrapper variations in deflateBound() +- Set examples/zpipe.c input and output to binary mode for Windows +- Update examples/zlib_how.html with new zpipe.c (also web site) +- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems + that gcc became pickier in 4.0) +- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain + un-versioned, the patch adds versioning only for symbols introduced in + zlib-1.2.0 or later. It also declares as local those symbols which are + not designed to be exported." [Levin] +- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure +- Do not initialize global static by default in trees.c, add a response + NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess] +- Don't use strerror() in gzio.c under WinCE [Yakimov] +- Don't use errno.h in zutil.h under WinCE [Yakimov] +- Move arguments for AR to its usage to allow replacing ar [Marot] +- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson] +- Improve inflateInit() and inflateInit2() documentation +- Fix structure size comment in inflate.h +- Change configure help option from --h* to --help [Santos] + +Changes in 1.2.3 (18 July 2005) +- Apply security vulnerability fixes to contrib/infback9 as well +- Clean up some text files (carriage returns, trailing space) +- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant] + +Changes in 1.2.2.4 (11 July 2005) +- Add inflatePrime() function for starting inflation at bit boundary +- Avoid some Visual C warnings in deflate.c +- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit + compile +- Fix some spelling errors in comments [Betts] +- Correct inflateInit2() error return documentation in zlib.h +- Add zran.c example of compressed data random access to examples + directory, shows use of inflatePrime() +- Fix cast for assignments to strm->state in inflate.c and infback.c +- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer] +- Move declarations of gf2 functions to right place in crc32.c [Oberhumer] +- Add cast in trees.c t avoid a warning [Oberhumer] +- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer] +- Update make_vms.com [Zinser] +- Initialize state->write in inflateReset() since copied in inflate_fast() +- Be more strict on incomplete code sets in inflate_table() and increase + ENOUGH and MAXD -- this repairs a possible security vulnerability for + invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for + discovering the vulnerability and providing test cases. +- Add ia64 support to configure for HP-UX [Smith] +- Add error return to gzread() for format or i/o error [Levin] +- Use malloc.h for OS/2 [Necasek] + +Changes in 1.2.2.3 (27 May 2005) +- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile +- Typecast fread() return values in gzio.c [Vollant] +- Remove trailing space in minigzip.c outmode (VC++ can't deal with it) +- Fix crc check bug in gzread() after gzungetc() [Heiner] +- Add the deflateTune() function to adjust internal compression parameters +- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack) +- Remove an incorrect assertion in examples/zpipe.c +- Add C++ wrapper in infback9.h [Donais] +- Fix bug in inflateCopy() when decoding fixed codes +- Note in zlib.h how much deflateSetDictionary() actually uses +- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used) +- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer] +- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer] +- Add gzdirect() function to indicate transparent reads +- Update contrib/minizip [Vollant] +- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer] +- Add casts in crc32.c to avoid warnings [Oberhumer] +- Add contrib/masmx64 [Vollant] +- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant] + +Changes in 1.2.2.2 (30 December 2004) +- Replace structure assignments in deflate.c and inflate.c with zmemcpy to + avoid implicit memcpy calls (portability for no-library compilation) +- Increase sprintf() buffer size in gzdopen() to allow for large numbers +- Add INFLATE_STRICT to check distances against zlib header +- Improve WinCE errno handling and comments [Chang] +- Remove comment about no gzip header processing in FAQ +- Add Z_FIXED strategy option to deflateInit2() to force fixed trees +- Add updated make_vms.com [Coghlan], update README +- Create a new "examples" directory, move gzappend.c there, add zpipe.c, + fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html. +- Add FAQ entry and comments in deflate.c on uninitialized memory access +- Add Solaris 9 make options in configure [Gilbert] +- Allow strerror() usage in gzio.c for STDC +- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer] +- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant] +- Use z_off_t for adler32_combine() and crc32_combine() lengths +- Make adler32() much faster for small len +- Use OS_CODE in deflate() default gzip header + +Changes in 1.2.2.1 (31 October 2004) +- Allow inflateSetDictionary() call for raw inflate +- Fix inflate header crc check bug for file names and comments +- Add deflateSetHeader() and gz_header structure for custom gzip headers +- Add inflateGetheader() to retrieve gzip headers +- Add crc32_combine() and adler32_combine() functions +- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list +- Use zstreamp consistently in zlib.h (inflate_back functions) +- Remove GUNZIP condition from definition of inflate_mode in inflate.h + and in contrib/inflate86/inffast.S [Truta, Anderson] +- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson] +- Update projects/README.projects and projects/visualc6 [Truta] +- Update win32/DLL_FAQ.txt [Truta] +- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta] +- Deprecate Z_ASCII; use Z_TEXT instead [Truta] +- Use a new algorithm for setting strm->data_type in trees.c [Truta] +- Do not define an exit() prototype in zutil.c unless DEBUG defined +- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta] +- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate() +- Fix Darwin build version identification [Peterson] + +Changes in 1.2.2 (3 October 2004) +- Update zlib.h comments on gzip in-memory processing +- Set adler to 1 in inflateReset() to support Java test suite [Walles] +- Add contrib/dotzlib [Ravn] +- Update win32/DLL_FAQ.txt [Truta] +- Update contrib/minizip [Vollant] +- Move contrib/visual-basic.txt to old/ [Truta] +- Fix assembler builds in projects/visualc6/ [Truta] + +Changes in 1.2.1.2 (9 September 2004) +- Update INDEX file +- Fix trees.c to update strm->data_type (no one ever noticed!) +- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown] +- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE) +- Add limited multitasking protection to DYNAMIC_CRC_TABLE +- Add NO_vsnprintf for VMS in zutil.h [Mozilla] +- Don't declare strerror() under VMS [Mozilla] +- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize +- Update contrib/ada [Anisimkov] +- Update contrib/minizip [Vollant] +- Fix configure to not hardcode directories for Darwin [Peterson] +- Fix gzio.c to not return error on empty files [Brown] +- Fix indentation; update version in contrib/delphi/ZLib.pas and + contrib/pascal/zlibpas.pas [Truta] +- Update mkasm.bat in contrib/masmx86 [Truta] +- Update contrib/untgz [Truta] +- Add projects/README.projects [Truta] +- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta] +- Update win32/DLL_FAQ.txt [Truta] +- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta] +- Remove an unnecessary assignment to curr in inftrees.c [Truta] +- Add OS/2 to exe builds in configure [Poltorak] +- Remove err dummy parameter in zlib.h [Kientzle] + +Changes in 1.2.1.1 (9 January 2004) +- Update email address in README +- Several FAQ updates +- Fix a big fat bug in inftrees.c that prevented decoding valid + dynamic blocks with only literals and no distance codes -- + Thanks to "Hot Emu" for the bug report and sample file +- Add a note to puff.c on no distance codes case. + +Changes in 1.2.1 (17 November 2003) +- Remove a tab in contrib/gzappend/gzappend.c +- Update some interfaces in contrib for new zlib functions +- Update zlib version number in some contrib entries +- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta] +- Support shared libraries on Hurd and KFreeBSD [Brown] +- Fix error in NO_DIVIDE option of adler32.c + +Changes in 1.2.0.8 (4 November 2003) +- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas +- Add experimental NO_DIVIDE #define in adler32.c + - Possibly faster on some processors (let me know if it is) +- Correct Z_BLOCK to not return on first inflate call if no wrap +- Fix strm->data_type on inflate() return to correctly indicate EOB +- Add deflatePrime() function for appending in the middle of a byte +- Add contrib/gzappend for an example of appending to a stream +- Update win32/DLL_FAQ.txt [Truta] +- Delete Turbo C comment in README [Truta] +- Improve some indentation in zconf.h [Truta] +- Fix infinite loop on bad input in configure script [Church] +- Fix gzeof() for concatenated gzip files [Johnson] +- Add example to contrib/visual-basic.txt [Michael B.] +- Add -p to mkdir's in Makefile.in [vda] +- Fix configure to properly detect presence or lack of printf functions +- Add AS400 support [Monnerat] +- Add a little Cygwin support [Wilson] + +Changes in 1.2.0.7 (21 September 2003) +- Correct some debug formats in contrib/infback9 +- Cast a type in a debug statement in trees.c +- Change search and replace delimiter in configure from % to # [Beebe] +- Update contrib/untgz to 0.2 with various fixes [Truta] +- Add build support for Amiga [Nikl] +- Remove some directories in old that have been updated to 1.2 +- Add dylib building for Mac OS X in configure and Makefile.in +- Remove old distribution stuff from Makefile +- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X +- Update links in README + +Changes in 1.2.0.6 (13 September 2003) +- Minor FAQ updates +- Update contrib/minizip to 1.00 [Vollant] +- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta] +- Update POSTINC comment for 68060 [Nikl] +- Add contrib/infback9 with deflate64 decoding (unsupported) +- For MVS define NO_vsnprintf and undefine FAR [van Burik] +- Add pragma for fdopen on MVS [van Burik] + +Changes in 1.2.0.5 (8 September 2003) +- Add OF to inflateBackEnd() declaration in zlib.h +- Remember start when using gzdopen in the middle of a file +- Use internal off_t counters in gz* functions to properly handle seeks +- Perform more rigorous check for distance-too-far in inffast.c +- Add Z_BLOCK flush option to return from inflate at block boundary +- Set strm->data_type on return from inflate + - Indicate bits unused, if at block boundary, and if in last block +- Replace size_t with ptrdiff_t in crc32.c, and check for correct size +- Add condition so old NO_DEFLATE define still works for compatibility +- FAQ update regarding the Windows DLL [Truta] +- INDEX update: add qnx entry, remove aix entry [Truta] +- Install zlib.3 into mandir [Wilson] +- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta] +- Adapt the zlib interface to the new DLL convention guidelines [Truta] +- Introduce ZLIB_WINAPI macro to allow the export of functions using + the WINAPI calling convention, for Visual Basic [Vollant, Truta] +- Update msdos and win32 scripts and makefiles [Truta] +- Export symbols by name, not by ordinal, in win32/zlib.def [Truta] +- Add contrib/ada [Anisimkov] +- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta] +- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant] +- Add contrib/masm686 [Truta] +- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm + [Truta, Vollant] +- Update contrib/delphi; rename to contrib/pascal; add example [Truta] +- Remove contrib/delphi2; add a new contrib/delphi [Truta] +- Avoid inclusion of the nonstandard in contrib/iostream, + and fix some method prototypes [Truta] +- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip + [Truta] +- Avoid the use of backslash (\) in contrib/minizip [Vollant] +- Fix file time handling in contrib/untgz; update makefiles [Truta] +- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines + [Vollant] +- Remove contrib/vstudio/vc15_16 [Vollant] +- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta] +- Update README.contrib [Truta] +- Invert the assignment order of match_head and s->prev[...] in + INSERT_STRING [Truta] +- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings + [Truta] +- Compare function pointers with 0, not with NULL or Z_NULL [Truta] +- Fix prototype of syncsearch in inflate.c [Truta] +- Introduce ASMINF macro to be enabled when using an ASM implementation + of inflate_fast [Truta] +- Change NO_DEFLATE to NO_GZCOMPRESS [Truta] +- Modify test_gzio in example.c to take a single file name as a + parameter [Truta] +- Exit the example.c program if gzopen fails [Truta] +- Add type casts around strlen in example.c [Truta] +- Remove casting to sizeof in minigzip.c; give a proper type + to the variable compared with SUFFIX_LEN [Truta] +- Update definitions of STDC and STDC99 in zconf.h [Truta] +- Synchronize zconf.h with the new Windows DLL interface [Truta] +- Use SYS16BIT instead of __32BIT__ to distinguish between + 16- and 32-bit platforms [Truta] +- Use far memory allocators in small 16-bit memory models for + Turbo C [Truta] +- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in + zlibCompileFlags [Truta] +- Cygwin has vsnprintf [Wilson] +- In Windows16, OS_CODE is 0, as in MSDOS [Truta] +- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson] + +Changes in 1.2.0.4 (10 August 2003) +- Minor FAQ updates +- Be more strict when checking inflateInit2's windowBits parameter +- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well +- Add gzip wrapper option to deflateInit2 using windowBits +- Add updated QNX rule in configure and qnx directory [Bonnefoy] +- Make inflate distance-too-far checks more rigorous +- Clean up FAR usage in inflate +- Add casting to sizeof() in gzio.c and minigzip.c + +Changes in 1.2.0.3 (19 July 2003) +- Fix silly error in gzungetc() implementation [Vollant] +- Update contrib/minizip and contrib/vstudio [Vollant] +- Fix printf format in example.c +- Correct cdecl support in zconf.in.h [Anisimkov] +- Minor FAQ updates + +Changes in 1.2.0.2 (13 July 2003) +- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons +- Attempt to avoid warnings in crc32.c for pointer-int conversion +- Add AIX to configure, remove aix directory [Bakker] +- Add some casts to minigzip.c +- Improve checking after insecure sprintf() or vsprintf() calls +- Remove #elif's from crc32.c +- Change leave label to inf_leave in inflate.c and infback.c to avoid + library conflicts +- Remove inflate gzip decoding by default--only enable gzip decoding by + special request for stricter backward compatibility +- Add zlibCompileFlags() function to return compilation information +- More typecasting in deflate.c to avoid warnings +- Remove leading underscore from _Capital #defines [Truta] +- Fix configure to link shared library when testing +- Add some Windows CE target adjustments [Mai] +- Remove #define ZLIB_DLL in zconf.h [Vollant] +- Add zlib.3 [Rodgers] +- Update RFC URL in deflate.c and algorithm.txt [Mai] +- Add zlib_dll_FAQ.txt to contrib [Truta] +- Add UL to some constants [Truta] +- Update minizip and vstudio [Vollant] +- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h +- Expand use of NO_DUMMY_DECL to avoid all dummy structures +- Added iostream3 to contrib [Schwardt] +- Replace rewind() with fseek() for WinCE [Truta] +- Improve setting of zlib format compression level flags + - Report 0 for huffman and rle strategies and for level == 0 or 1 + - Report 2 only for level == 6 +- Only deal with 64K limit when necessary at compile time [Truta] +- Allow TOO_FAR check to be turned off at compile time [Truta] +- Add gzclearerr() function [Souza] +- Add gzungetc() function + +Changes in 1.2.0.1 (17 March 2003) +- Add Z_RLE strategy for run-length encoding [Truta] + - When Z_RLE requested, restrict matches to distance one + - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE +- Correct FASTEST compilation to allow level == 0 +- Clean up what gets compiled for FASTEST +- Incorporate changes to zconf.in.h [Vollant] + - Refine detection of Turbo C need for dummy returns + - Refine ZLIB_DLL compilation + - Include additional header file on VMS for off_t typedef +- Try to use _vsnprintf where it supplants vsprintf [Vollant] +- Add some casts in inffast.c +- Enchance comments in zlib.h on what happens if gzprintf() tries to + write more than 4095 bytes before compression +- Remove unused state from inflateBackEnd() +- Remove exit(0) from minigzip.c, example.c +- Get rid of all those darn tabs +- Add "check" target to Makefile.in that does the same thing as "test" +- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in +- Update contrib/inflate86 [Anderson] +- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant] +- Add msdos and win32 directories with makefiles [Truta] +- More additions and improvements to the FAQ + +Changes in 1.2.0 (9 March 2003) +- New and improved inflate code + - About 20% faster + - Does not allocate 32K window unless and until needed + - Automatically detects and decompresses gzip streams + - Raw inflate no longer needs an extra dummy byte at end + - Added inflateBack functions using a callback interface--even faster + than inflate, useful for file utilities (gzip, zip) + - Added inflateCopy() function to record state for random access on + externally generated deflate streams (e.g. in gzip files) + - More readable code (I hope) +- New and improved crc32() + - About 50% faster, thanks to suggestions from Rodney Brown +- Add deflateBound() and compressBound() functions +- Fix memory leak in deflateInit2() +- Permit setting dictionary for raw deflate (for parallel deflate) +- Fix const declaration for gzwrite() +- Check for some malloc() failures in gzio.c +- Fix bug in gzopen() on single-byte file 0x1f +- Fix bug in gzread() on concatenated file with 0x1f at end of buffer + and next buffer doesn't start with 0x8b +- Fix uncompress() to return Z_DATA_ERROR on truncated input +- Free memory at end of example.c +- Remove MAX #define in trees.c (conflicted with some libraries) +- Fix static const's in deflate.c, gzio.c, and zutil.[ch] +- Declare malloc() and free() in gzio.c if STDC not defined +- Use malloc() instead of calloc() in zutil.c if int big enough +- Define STDC for AIX +- Add aix/ with approach for compiling shared library on AIX +- Add HP-UX support for shared libraries in configure +- Add OpenUNIX support for shared libraries in configure +- Use $cc instead of gcc to build shared library +- Make prefix directory if needed when installing +- Correct Macintosh avoidance of typedef Byte in zconf.h +- Correct Turbo C memory allocation when under Linux +- Use libz.a instead of -lz in Makefile (assure use of compiled library) +- Update configure to check for snprintf or vsnprintf functions and their + return value, warn during make if using an insecure function +- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that + is lost when library is used--resolution is to build new zconf.h +- Documentation improvements (in zlib.h): + - Document raw deflate and inflate + - Update RFCs URL + - Point out that zlib and gzip formats are different + - Note that Z_BUF_ERROR is not fatal + - Document string limit for gzprintf() and possible buffer overflow + - Note requirement on avail_out when flushing + - Note permitted values of flush parameter of inflate() +- Add some FAQs (and even answers) to the FAQ +- Add contrib/inflate86/ for x86 faster inflate +- Add contrib/blast/ for PKWare Data Compression Library decompression +- Add contrib/puff/ simple inflate for deflate format description + +Changes in 1.1.4 (11 March 2002) +- ZFREE was repeated on same allocation on some error conditions. + This creates a security problem described in + http://www.zlib.org/advisory-2002-03-11.txt +- Returned incorrect error (Z_MEM_ERROR) on some invalid data +- Avoid accesses before window for invalid distances with inflate window + less than 32K. +- force windowBits > 8 to avoid a bug in the encoder for a window size + of 256 bytes. (A complete fix will be available in 1.1.5). + +Changes in 1.1.3 (9 July 1998) +- fix "an inflate input buffer bug that shows up on rare but persistent + occasions" (Mark) +- fix gzread and gztell for concatenated .gz files (Didier Le Botlan) +- fix gzseek(..., SEEK_SET) in write mode +- fix crc check after a gzeek (Frank Faubert) +- fix miniunzip when the last entry in a zip file is itself a zip file + (J Lillge) +- add contrib/asm586 and contrib/asm686 (Brian Raiter) + See http://www.muppetlabs.com/~breadbox/software/assembly.html +- add support for Delphi 3 in contrib/delphi (Bob Dellaca) +- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti) +- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren) +- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks) +- added a FAQ file + +- Support gzdopen on Mac with Metrowerks (Jason Linhart) +- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart) +- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young) +- avoid some warnings with Borland C (Tom Tanner) +- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant) +- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant) +- allow several arguments to configure (Tim Mooney, Frodo Looijaard) +- use libdir and includedir in Makefile.in (Tim Mooney) +- support shared libraries on OSF1 V4 (Tim Mooney) +- remove so_locations in "make clean" (Tim Mooney) +- fix maketree.c compilation error (Glenn, Mark) +- Python interface to zlib now in Python 1.5 (Jeremy Hylton) +- new Makefile.riscos (Rich Walker) +- initialize static descriptors in trees.c for embedded targets (Nick Smith) +- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith) +- add the OS/2 files in Makefile.in too (Andrew Zabolotny) +- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane) +- fix maketree.c to allow clean compilation of inffixed.h (Mark) +- fix parameter check in deflateCopy (Gunther Nikl) +- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler) +- Many portability patches by Christian Spieler: + . zutil.c, zutil.h: added "const" for zmem* + . Make_vms.com: fixed some typos + . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists + . msdos/Makefile.msc: remove "default rtl link library" info from obj files + . msdos/Makefile.*: use model-dependent name for the built zlib library + . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc: + new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT) +- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane) +- replace __far with _far for better portability (Christian Spieler, Tom Lane) +- fix test for errno.h in configure (Tim Newsham) + +Changes in 1.1.2 (19 March 98) +- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant) + See http://www.winimage.com/zLibDll/unzip.html +- preinitialize the inflate tables for fixed codes, to make the code + completely thread safe (Mark) +- some simplifications and slight speed-up to the inflate code (Mark) +- fix gzeof on non-compressed files (Allan Schrum) +- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs) +- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn) +- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny) +- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori) +- do not wrap extern "C" around system includes (Tom Lane) +- mention zlib binding for TCL in README (Andreas Kupries) +- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert) +- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson) +- allow "configure --prefix $HOME" (Tim Mooney) +- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson) +- move Makefile.sas to amiga/Makefile.sas + +Changes in 1.1.1 (27 Feb 98) +- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson) +- remove block truncation heuristic which had very marginal effect for zlib + (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the + compression ratio on some files. This also allows inlining _tr_tally for + matches in deflate_slow. +- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier) + +Changes in 1.1.0 (24 Feb 98) +- do not return STREAM_END prematurely in inflate (John Bowler) +- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler) +- compile with -DFASTEST to get compression code optimized for speed only +- in minigzip, try mmap'ing the input file first (Miguel Albrecht) +- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain + on Sun but significant on HP) + +- add a pointer to experimental unzip library in README (Gilles Vollant) +- initialize variable gcc in configure (Chris Herborth) + +Changes in 1.0.9 (17 Feb 1998) +- added gzputs and gzgets functions +- do not clear eof flag in gzseek (Mark Diekhans) +- fix gzseek for files in transparent mode (Mark Diekhans) +- do not assume that vsprintf returns the number of bytes written (Jens Krinke) +- replace EXPORT with ZEXPORT to avoid conflict with other programs +- added compress2 in zconf.h, zlib.def, zlib.dnt +- new asm code from Gilles Vollant in contrib/asm386 +- simplify the inflate code (Mark): + . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new() + . ZALLOC the length list in inflate_trees_fixed() instead of using stack + . ZALLOC the value area for huft_build() instead of using stack + . Simplify Z_FINISH check in inflate() + +- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8 +- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi) +- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with + the declaration of FAR (Gilles VOllant) +- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann) +- read_buf buf parameter of type Bytef* instead of charf* +- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout) +- do not redeclare unlink in minigzip.c for WIN32 (John Bowler) +- fix check for presence of directories in "make install" (Ian Willis) + +Changes in 1.0.8 (27 Jan 1998) +- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant) +- fix gzgetc and gzputc for big endian systems (Markus Oberhumer) +- added compress2() to allow setting the compression level +- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong) +- use constant arrays for the static trees in trees.c instead of computing + them at run time (thanks to Ken Raeburn for this suggestion). To create + trees.h, compile with GEN_TREES_H and run "make test". +- check return code of example in "make test" and display result +- pass minigzip command line options to file_compress +- simplifying code of inflateSync to avoid gcc 2.8 bug + +- support CC="gcc -Wall" in configure -s (QingLong) +- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn) +- fix test for shared library support to avoid compiler warnings +- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant) +- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit) +- do not use fdopen for Metrowerks on Mac (Brad Pettit)) +- add checks for gzputc and gzputc in example.c +- avoid warnings in gzio.c and deflate.c (Andreas Kleinert) +- use const for the CRC table (Ken Raeburn) +- fixed "make uninstall" for shared libraries +- use Tracev instead of Trace in infblock.c +- in example.c use correct compressed length for test_sync +- suppress +vnocompatwarnings in configure for HPUX (not always supported) + +Changes in 1.0.7 (20 Jan 1998) +- fix gzseek which was broken in write mode +- return error for gzseek to negative absolute position +- fix configure for Linux (Chun-Chung Chen) +- increase stack space for MSC (Tim Wegner) +- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant) +- define EXPORTVA for gzprintf (Gilles Vollant) +- added man page zlib.3 (Rick Rodgers) +- for contrib/untgz, fix makedir() and improve Makefile + +- check gzseek in write mode in example.c +- allocate extra buffer for seeks only if gzseek is actually called +- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant) +- add inflateSyncPoint in zconf.h +- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def + +Changes in 1.0.6 (19 Jan 1998) +- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and + gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code) +- Fix a deflate bug occurring only with compression level 0 (thanks to + Andy Buckler for finding this one). +- In minigzip, pass transparently also the first byte for .Z files. +- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress() +- check Z_FINISH in inflate (thanks to Marc Schluper) +- Implement deflateCopy (thanks to Adam Costello) +- make static libraries by default in configure, add --shared option. +- move MSDOS or Windows specific files to directory msdos +- suppress the notion of partial flush to simplify the interface + (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4) +- suppress history buffer provided by application to simplify the interface + (this feature was not implemented anyway in 1.0.4) +- next_in and avail_in must be initialized before calling inflateInit or + inflateInit2 +- add EXPORT in all exported functions (for Windows DLL) +- added Makefile.nt (thanks to Stephen Williams) +- added the unsupported "contrib" directory: + contrib/asm386/ by Gilles Vollant + 386 asm code replacing longest_match(). + contrib/iostream/ by Kevin Ruland + A C++ I/O streams interface to the zlib gz* functions + contrib/iostream2/ by Tyge Løvset + Another C++ I/O streams interface + contrib/untgz/ by "Pedro A. Aranda Guti\irrez" + A very simple tar.gz file extractor using zlib + contrib/visual-basic.txt by Carlos Rios + How to use compress(), uncompress() and the gz* functions from VB. +- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression + level) in minigzip (thanks to Tom Lane) + +- use const for rommable constants in deflate +- added test for gzseek and gztell in example.c +- add undocumented function inflateSyncPoint() (hack for Paul Mackerras) +- add undocumented function zError to convert error code to string + (for Tim Smithers) +- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code. +- Use default memcpy for Symantec MSDOS compiler. +- Add EXPORT keyword for check_func (needed for Windows DLL) +- add current directory to LD_LIBRARY_PATH for "make test" +- create also a link for libz.so.1 +- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura) +- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX) +- added -soname for Linux in configure (Chun-Chung Chen, +- assign numbers to the exported functions in zlib.def (for Windows DLL) +- add advice in zlib.h for best usage of deflateSetDictionary +- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn) +- allow compilation with ANSI keywords only enabled for TurboC in large model +- avoid "versionString"[0] (Borland bug) +- add NEED_DUMMY_RETURN for Borland +- use variable z_verbose for tracing in debug mode (L. Peter Deutsch). +- allow compilation with CC +- defined STDC for OS/2 (David Charlap) +- limit external names to 8 chars for MVS (Thomas Lund) +- in minigzip.c, use static buffers only for 16-bit systems +- fix suffix check for "minigzip -d foo.gz" +- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee) +- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau) +- added makelcc.bat for lcc-win32 (Tom St Denis) +- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe) +- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion. +- check for unistd.h in configure (for off_t) +- remove useless check parameter in inflate_blocks_free +- avoid useless assignment of s->check to itself in inflate_blocks_new +- do not flush twice in gzclose (thanks to Ken Raeburn) +- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h +- use NO_ERRNO_H instead of enumeration of operating systems with errno.h +- work around buggy fclose on pipes for HP/UX +- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson) +- fix configure if CC is already equal to gcc + +Changes in 1.0.5 (3 Jan 98) +- Fix inflate to terminate gracefully when fed corrupted or invalid data +- Use const for rommable constants in inflate +- Eliminate memory leaks on error conditions in inflate +- Removed some vestigial code in inflate +- Update web address in README + +Changes in 1.0.4 (24 Jul 96) +- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF + bit, so the decompressor could decompress all the correct data but went + on to attempt decompressing extra garbage data. This affected minigzip too. +- zlibVersion and gzerror return const char* (needed for DLL) +- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno) +- use z_error only for DEBUG (avoid problem with DLLs) + +Changes in 1.0.3 (2 Jul 96) +- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS + small and medium models; this makes the library incompatible with previous + versions for these models. (No effect in large model or on other systems.) +- return OK instead of BUF_ERROR if previous deflate call returned with + avail_out as zero but there is nothing to do +- added memcmp for non STDC compilers +- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly) +- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO) +- better check for 16-bit mode MSC (avoids problem with Symantec) + +Changes in 1.0.2 (23 May 96) +- added Windows DLL support +- added a function zlibVersion (for the DLL support) +- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model) +- Bytef is define's instead of typedef'd only for Borland C +- avoid reading uninitialized memory in example.c +- mention in README that the zlib format is now RFC1950 +- updated Makefile.dj2 +- added algorithm.doc + +Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion] +- fix array overlay in deflate.c which sometimes caused bad compressed data +- fix inflate bug with empty stored block +- fix MSDOS medium model which was broken in 0.99 +- fix deflateParams() which could generated bad compressed data. +- Bytef is define'd instead of typedef'ed (work around Borland bug) +- added an INDEX file +- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), + Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) +- speed up adler32 for modern machines without auto-increment +- added -ansi for IRIX in configure +- static_init_done in trees.c is an int +- define unlink as delete for VMS +- fix configure for QNX +- add configure branch for SCO and HPUX +- avoid many warnings (unused variables, dead assignments, etc...) +- no fdopen for BeOS +- fix the Watcom fix for 32 bit mode (define FAR as empty) +- removed redefinition of Byte for MKWERKS +- work around an MWKERKS bug (incorrect merge of all .h files) + +Changes in 0.99 (27 Jan 96) +- allow preset dictionary shared between compressor and decompressor +- allow compression level 0 (no compression) +- add deflateParams in zlib.h: allow dynamic change of compression level + and compression strategy. +- test large buffers and deflateParams in example.c +- add optional "configure" to build zlib as a shared library +- suppress Makefile.qnx, use configure instead +- fixed deflate for 64-bit systems (detected on Cray) +- fixed inflate_blocks for 64-bit systems (detected on Alpha) +- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) +- always return Z_BUF_ERROR when deflate() has nothing to do +- deflateInit and inflateInit are now macros to allow version checking +- prefix all global functions and types with z_ with -DZ_PREFIX +- make falloc completely reentrant (inftrees.c) +- fixed very unlikely race condition in ct_static_init +- free in reverse order of allocation to help memory manager +- use zlib-1.0/* instead of zlib/* inside the tar.gz +- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith + -Wconversion -Wstrict-prototypes -Wmissing-prototypes" +- allow gzread on concatenated .gz files +- deflateEnd now returns Z_DATA_ERROR if it was premature +- deflate is finally (?) fully deterministic (no matches beyond end of input) +- Document Z_SYNC_FLUSH +- add uninstall in Makefile +- Check for __cpluplus in zlib.h +- Better test in ct_align for partial flush +- avoid harmless warnings for Borland C++ +- initialize hash_head in deflate.c +- avoid warning on fdopen (gzio.c) for HP cc -Aa +- include stdlib.h for STDC compilers +- include errno.h for Cray +- ignore error if ranlib doesn't exist +- call ranlib twice for NeXTSTEP +- use exec_prefix instead of prefix for libz.a +- renamed ct_* as _tr_* to avoid conflict with applications +- clear z->msg in inflateInit2 before any error return +- initialize opaque in example.c, gzio.c, deflate.c and inflate.c +- fixed typo in zconf.h (_GNUC__ => __GNUC__) +- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode) +- fix typo in Make_vms.com (f$trnlnm -> f$getsyi) +- in fcalloc, normalize pointer if size > 65520 bytes +- don't use special fcalloc for 32 bit Borland C++ +- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... +- use Z_BINARY instead of BINARY +- document that gzclose after gzdopen will close the file +- allow "a" as mode in gzopen. +- fix error checking in gzread +- allow skipping .gz extra-field on pipes +- added reference to Perl interface in README +- put the crc table in FAR data (I dislike more and more the medium model :) +- added get_crc_table +- added a dimension to all arrays (Borland C can't count). +- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast +- guard against multiple inclusion of *.h (for precompiled header on Mac) +- Watcom C pretends to be Microsoft C small model even in 32 bit mode. +- don't use unsized arrays to avoid silly warnings by Visual C++: + warning C4746: 'inflate_mask' : unsized array treated as '__far' + (what's wrong with far data in far model?). +- define enum out of inflate_blocks_state to allow compilation with C++ + +Changes in 0.95 (16 Aug 95) +- fix MSDOS small and medium model (now easier to adapt to any compiler) +- inlined send_bits +- fix the final (:-) bug for deflate with flush (output was correct but + not completely flushed in rare occasions). +- default window size is same for compression and decompression + (it's now sufficient to set MAX_WBITS in zconf.h). +- voidp -> voidpf and voidnp -> voidp (for consistency with other + typedefs and because voidnp was not near in large model). + +Changes in 0.94 (13 Aug 95) +- support MSDOS medium model +- fix deflate with flush (could sometimes generate bad output) +- fix deflateReset (zlib header was incorrectly suppressed) +- added support for VMS +- allow a compression level in gzopen() +- gzflush now calls fflush +- For deflate with flush, flush even if no more input is provided. +- rename libgz.a as libz.a +- avoid complex expression in infcodes.c triggering Turbo C bug +- work around a problem with gcc on Alpha (in INSERT_STRING) +- don't use inline functions (problem with some gcc versions) +- allow renaming of Byte, uInt, etc... with #define. +- avoid warning about (unused) pointer before start of array in deflate.c +- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c +- avoid reserved word 'new' in trees.c + +Changes in 0.93 (25 June 95) +- temporarily disable inline functions +- make deflate deterministic +- give enough lookahead for PARTIAL_FLUSH +- Set binary mode for stdin/stdout in minigzip.c for OS/2 +- don't even use signed char in inflate (not portable enough) +- fix inflate memory leak for segmented architectures + +Changes in 0.92 (3 May 95) +- don't assume that char is signed (problem on SGI) +- Clear bit buffer when starting a stored block +- no memcpy on Pyramid +- suppressed inftest.c +- optimized fill_window, put longest_match inline for gcc +- optimized inflate on stored blocks. +- untabify all sources to simplify patches + +Changes in 0.91 (2 May 95) +- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h +- Document the memory requirements in zconf.h +- added "make install" +- fix sync search logic in inflateSync +- deflate(Z_FULL_FLUSH) now works even if output buffer too short +- after inflateSync, don't scare people with just "lo world" +- added support for DJGPP + +Changes in 0.9 (1 May 95) +- don't assume that zalloc clears the allocated memory (the TurboC bug + was Mark's bug after all :) +- let again gzread copy uncompressed data unchanged (was working in 0.71) +- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented +- added a test of inflateSync in example.c +- moved MAX_WBITS to zconf.h because users might want to change that. +- document explicitly that zalloc(64K) on MSDOS must return a normalized + pointer (zero offset) +- added Makefiles for Microsoft C, Turbo C, Borland C++ +- faster crc32() + +Changes in 0.8 (29 April 95) +- added fast inflate (inffast.c) +- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this + is incompatible with previous versions of zlib which returned Z_OK. +- work around a TurboC compiler bug (bad code for b << 0, see infutil.h) + (actually that was not a compiler bug, see 0.81 above) +- gzread no longer reads one extra byte in certain cases +- In gzio destroy(), don't reference a freed structure +- avoid many warnings for MSDOS +- avoid the ERROR symbol which is used by MS Windows + +Changes in 0.71 (14 April 95) +- Fixed more MSDOS compilation problems :( There is still a bug with + TurboC large model. + +Changes in 0.7 (14 April 95) +- Added full inflate support. +- Simplified the crc32() interface. The pre- and post-conditioning + (one's complement) is now done inside crc32(). WARNING: this is + incompatible with previous versions; see zlib.h for the new usage. + +Changes in 0.61 (12 April 95) +- workaround for a bug in TurboC. example and minigzip now work on MSDOS. + +Changes in 0.6 (11 April 95) +- added minigzip.c +- added gzdopen to reopen a file descriptor as gzFile +- added transparent reading of non-gziped files in gzread. +- fixed bug in gzread (don't read crc as data) +- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose). +- don't allocate big arrays in the stack (for MSDOS) +- fix some MSDOS compilation problems + +Changes in 0.5: +- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but + not yet Z_FULL_FLUSH. +- support decompression but only in a single step (forced Z_FINISH) +- added opaque object for zalloc and zfree. +- added deflateReset and inflateReset +- added a variable zlib_version for consistency checking. +- renamed the 'filter' parameter of deflateInit2 as 'strategy'. + Added Z_FILTERED and Z_HUFFMAN_ONLY constants. + +Changes in 0.4: +- avoid "zip" everywhere, use zlib instead of ziplib. +- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush + if compression method == 8. +- added adler32 and crc32 +- renamed deflateOptions as deflateInit2, call one or the other but not both +- added the method parameter for deflateInit2. +- added inflateInit2 +- simplied considerably deflateInit and inflateInit by not supporting + user-provided history buffer. This is supported only in deflateInit2 + and inflateInit2. + +Changes in 0.3: +- prefix all macro names with Z_ +- use Z_FINISH instead of deflateEnd to finish compression. +- added Z_HUFFMAN_ONLY +- added gzerror() diff --git a/zlib/src/Debug/adler32.obj b/zlib/src/Debug/adler32.obj new file mode 100644 index 0000000000000000000000000000000000000000..c7ab0224cf1643b78a172847a261cc274746fabf GIT binary patch literal 6305 zcmeHLeQ;C95kFyL3rX0|uHBM^q=K5(41@3oafm4iF&4zc!p61&NkoJ!$+oa9IntA{ z9b9A-Iw&F?^3f7P8z^mOn!*H{HVGg7hzTuBAZh6|Z7F49Tz86rKWt)JO(UxQ_TGC! z7DO|t{a2?qy7$}L+uPgSx9{$B)v64(an0RpET3m=29t`x;dR=@PN&>tMIh2uN=rtK zzzhy&qrbVJUg_DSV{9Sh4o#Ohd4Q!%sF39v6uA}>QbR-DVJ*)FSiOZbxCr1y?#NZarr~$ z>W1p7it^cbEHgD!&K}RLsjgi0kjYp-TTkqakx3t9IY23id z*;jMmD9dEI(ER4BERH6Z-RtprnnZnJ-CTW5hv;f|^|;*4`emN>4i_}A>ljghs+0p$ z857XJtKsFZX^edVl;Xoa(DT^}?t>)37>yyB9|A2jm=~37BAdx_g*aE~l`xQt$+S6Y zv}U975iAQFn!Xf+8vRYYP2>HjZB94KMt?LGi_r+5zr6&uYI7oBkbs*_VKuPs8t4GM zShWj-vwR9 zmgfNCg~pIf7Vw-hkR|(W<<2WHjSrTH&+Po?FpfJSo{L#fqQ@>z`ek!nE$&#is3$Ba!xAmPzi5xPQpfZUs6ue7<%92 z!+B-kE$^jl;iP6|{Kec{S1(?@3;c0P!`9TNzuhwD1>7ubgug?6kw^2GJ2YZzV+S@_g2~Aw{!1mWxxD6 zlJysyKX~l;#XBCnGc&gP{(Dy(IFHRG4KF}Y9eCt7L#=i}eEiGrkA7)XjqufT{`1zw zzj6y}cTZn;^pyv4&l!>1oUgI(|9xJ~p8kV7>-X&)T7HhPj}eENv{=~7EgfD@v)9(H zZ^AC_(-(FvDw}I*kMH)K(t*M!9Vm)R3`LesyT#?UxA`4Ti?7>f5xYB_K10idRf!Iq zOD08+&D#t;j&h45el8mC20s_U?@u`wDJLTPB>3cTHciNu9>3^no0tYEtp9yDdh8xI zIWfUpX~T(8oP)ykBHMdG|@ocA(L zhxDf}lMTs~mR*u54O@>tZq%z~4w=%>6gVH}=TDvYy^-9WT@~NBvvsg*|JH6eFo89L z{~^WFSX@$M=x{W$Yoq4y)!E13_g@m`#A1w5%cSnR$Z3;0 z*ej^~=A&ds>v0w~>9XI-Q>B^JA+x%#S3QaWUM)t?Cn{uAhfUEmlR9LI_Vq@2r!H)c z_Fd+^W=s?99}u)g_3%tYBiO5Be$8Q0J*?wxLGU$&jRMRHn}p!7Duie67!&njGv=L= zW>oVjbisafk!Eg4^vdbmnqrKW{_Y6P{Lj%);@o=??7m*%P(EYXTWAvun}xp1)C`%0 zlg7vsu!vjLdJ0{bI9;R6EIY@;(Lcz-M)c|g?y)*<4j+4VU|g)=IoAVl9&(N)YVL zW1EFd8I-_2b?{Vd82?pp+0sHwWZ0Mo^@5}x&Vy^Wp;Pvk=eAFw3Fn!{(o7NPy6r}xFtN2n<*fxf zN@OsmVqQcu(l<;b9~~iWV45S!Hbds|Z6+E#p_Ah@E}oLBu(}T3)!q`(mV{o3G$h;MOwos&`BH71Sv)tw~Eb-=>{QI;~bjwMF%dl^PQv8qK z!X-1Tw}{|U#A>Z;SY}<;;Y(A<Z(s)4$nq+Qg7TrNrxg8_uxNo CGFxo` literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/compress.obj b/zlib/src/Debug/compress.obj new file mode 100644 index 0000000000000000000000000000000000000000..8a36ab71af9d6de9148513cad4bba83fc6456b83 GIT binary patch literal 4508 zcmb_feQZXl_Q9i8KRl$uc1G~_`7ar0>c%$esrzXTJnN~(NCOX<_f{JRYwjn09BYyxb(xi6Ee&@dT z923+{S~$sl=bYa?_uO;Oy}lpqj#Apwx3cfGB}5XLOgj=s>iNzx`-mMi@Qyv60C_l&6ZuSZMO@;+A>=+xoHW!*>RzL2 zBxRds(C1Ou`7j11ZX!|VSN)oyRJDb63J{-Sl!LH&-m*h8YVrh{gkA5gcCWzZ@H{(7 zl4@GyO^=7$d)wQZ8&~18G1S|#>Q=O)z2%9=Lvqh5iTk^batNh|99}SLX^ga_mF$R` zGW5u{gr1Ehr5+<2Po$-~Ky7`bQ%mng^7V+Ws75-SjOij(cI+iU#*kG5*XsEkb?Gyj*abdr;5(0!J(;pNl$?40dW0 zJF^JMD5tW*)c$w%&SuVod@e&I21-&LRg<&?$kgoYEF-F>iAk7--o}$)XliUkq?@EzcO za2>n`{3-BS@Na?Ffxie|5B`1d2JlnhYr)Te2f_agz7G5%cq91y`Idk)*;6uq?T?_Y ze%^dbz<3?qhw={cVp4v-o734;{D1racp*E{?)HTYkaNp(H!W6<-SnmMm zI6A@kxB7dOa&mgvakf338X6=wR0(SHK10PGIj0Pg2U@d-Xn)k4+YEl0PA|{3jR4{5OxX%L&bE>-Uhu6-~vlHdGC%>za^5186Ie;_idL=q__nT@LveV-mN_GMJv zziYv+jCf2Nf}eO}B%VLtZtY&2Z;1C(&NutW@GEy9n7BH)pkVmaU6=zUo#GG{I7LaE z+r}N3A4M~ek~`o?k0lpAD&$7VYMPo-_T3SGqcLl6RlNbJN*%~Z8^977iS-6)jr0`( z0B68dbW;hUc7sI!Z$qi7u0c3`WUcf?;Tb<`Se_DwuFd9ngVlU(uPv7GD~m#1?f-+1T`xv+CQ{HL5;mUE7W zF2H3@zOa6g;hOvySDX(Hq0w3S3U_c;7T(XwGpy|n?qZe;E$f;HPj_1(!0pt5C#T3* zoRg=n_U$g7kf-hNoMxTFSUnM%?y?#bvvu~av$E*!YDq3UH6EVK$&*)Ca7dv`a%=@5^Rzkvoio)+nUaut-gv6`41jQsC<($URlu#2N5B@~_#Nofu z>@44bng-RF;SU53IcUs83g4}8N=1%<>9F8i_-4fq05<$;6?x5D6~0&bm@RUMY0uZQ z;E&I}Rq?ZcjUDl}ADqP9fT^lyb8Rqa#vp8{@a4J~7DWzzyOu!;R=$0d+Ym*umnHe) zBuL^70L1N0vJsvkrp06f0a?c;fkH$q%184^;rpDkSLEPPqS_*JxKCRVvtyaQ@ zjzhCEE8|)owXYj#)sF=EQ_wwR_j1t~fQ%X-FA dxkYnKS1q+?SJsH9_oU|4=EraPu&wd~{14_Q&Cmb< literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/crc32.obj b/zlib/src/Debug/crc32.obj new file mode 100644 index 0000000000000000000000000000000000000000..2128a66f06d25fdc95ae781647a35f07df7c03cc GIT binary patch literal 20602 zcmeHvc|29${`WQ?^AJ*~6OtiwA<9t3B7{g}Jmz^ONf|OkNromg2n{k15fMq0c}%7x znq;UDc|QA`<9w@o@ADhJ_x1eq-1TaEzt?Ad*1Xndt+hLA>yXhP0VcdA=XDTd8$xj6 zcHTH!Uw<6Yi%0_5PPXPFA{`4NZiln+a}Y3G3u#%0Am*Sa#6ghk0#HF%_7e4s*7O{K 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 A2><{9 literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/gzlib.obj b/zlib/src/Debug/gzlib.obj new file mode 100644 index 0000000000000000000000000000000000000000..a7c3c8aaddc5a57898597a042d548eb63348c575 GIT binary patch literal 16594 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 NZ9JorRm!%`{{jzEPM81y literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/gzread.obj b/zlib/src/Debug/gzread.obj new file mode 100644 index 0000000000000000000000000000000000000000..0249a38d473d9a56f0505a7f8cdad4ecedf12aa0 GIT binary patch literal 16221 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

(MzI!8-oN|s-uRxuw z+v~9@Po6cl3Y)5eq5w6{g)$`A0mUD@UjQfQRvv>g^zwpD{Wny;F83akQTGTKr|B9Y zsIi)Q8_JmJaic7mgHT4ftx){Y+x39a${kQg>AHKMj?j0XvhThH#ZfCY{$lg;DCE+- zlc9`OE`>5Q^gPr=-CiLTCuph;>U2$Qg)+*mrin?KCttJ}JhD1X;XmeNrl~qtB}a*+ zt^Rv&enSlm$hW~&&4H$9X<3>4io@Wf|E?2f;`6D;M)UaBUERayrPq;q_# zipC6%l$P)8E<(IPj#ynSF=db=RAv*u53E9(BVP?!4Bd`o&L6@-Kl+>VXH5yk^7J>WDo&h| zk!CBSOlb8^0*S$qGHqOC_~#%;Rv&r4GFVH#6uTAg8!U6VRMp9vukTn4Tf*Bv!;#g@ zNK&hK(RouPTJmcHTE>1fM^=dyLpZX6_|rL4#K)`joSLA#r9s6MyWt7a`-M!!R~ ze8U^`+kUbn5aG8X%$@mrE-3TYI#AYcRji5&g00c1jY@w*CNEp`oa@&vnliqY7dtS& zjTO@P)Uv8^$+EePb6Wzw)k~vIzSZY9g(FoJ_^-|OMmo%_^itgv37FZXEwQLSbV)Gd OuB|+y4Xc!`o&N;~z$mr= literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/gzwrite.obj b/zlib/src/Debug/gzwrite.obj new file mode 100644 index 0000000000000000000000000000000000000000..fce3004b15ce3ffa88f7e5524fbd9d7291776227 GIT binary patch literal 14028 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 D2dGrg literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/infback.obj b/zlib/src/Debug/infback.obj new file mode 100644 index 0000000000000000000000000000000000000000..087117b782d07569f6c674e14d100a8adb986058 GIT binary patch literal 18938 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 ZB+mE^nh~jKQ~G!gR)7&@AW*P`{}-&f^Wp#i literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/inffast.obj b/zlib/src/Debug/inffast.obj new file mode 100644 index 0000000000000000000000000000000000000000..689bc4fdf378daf001c6bb3a5b269be59909a2c0 GIT binary patch literal 7519 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 literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/inftrees.obj b/zlib/src/Debug/inftrees.obj new file mode 100644 index 0000000000000000000000000000000000000000..d41d2cf5d55992da42d6414e3cbcbf06f98ccbca GIT binary patch literal 7415 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 literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/uncompr.obj b/zlib/src/Debug/uncompr.obj new file mode 100644 index 0000000000000000000000000000000000000000..bc9304c5fddd75c8c4b2cc844f8456df3f9c7534 GIT binary patch literal 3691 zcmb_feQaA-6+dp8kJ-s;hh&tlD{sZxvX;4alC55{vNW|(nYP(@JGX{ncK6Nm|lHrR)>uGJ8*LAwP}AVAsHF^Pc+XrikEg0+7%9hD|cQ}~_x z-gBKz&R+>l&&h~m};vOgz!a|quJ>8 zQXr)c7KZ%2&dB*{A{ln~-e56sNgd?vwC(yFyI}|~*ftJl*(J@SLjbGr)Vs?Fh#eF> z9Wd2{rhim(MsCKMt6|r|3!?E9iMqcQ&`rhP72hjJbSv>Z0h^l(>R9_C|;ZJRS?~Tj5&L_0zOFF#U9G%+yq7B-(Nzqb31UZawR)O@7Iat7;;R z4@S)00w$Tw<`j$K*a{qKmu8CCN^yhyFP<8_3;dDSCHEe9v+DFf=hqW+uNA-b4mKYX z{KH53CpTRPytwQ5tEqpR4*RA=dSH1{=S1~T<|Bp^2hlR#cS@p?d-xA7HW`o9emD2d78&cE3@ZERFqoosJ%sO-o>(B``2ZHjLB4;!u zTS%$0F>c7_cwRLE!^?JMrjq&){G{6CRO!rHy1Y2^5bvj)dCqC4T!&avYI<3*@Ikyh z2TD%k5SICdvN+4l>+pIM-9$>RgCirEUH-0+8>OJ@s-}!z7k^_(dvpH2pyXEv^U@YT zCNHtxDs7a$DhTjQSc+jOVT^8(B!6?O7~9+|-6;&jUCvif6~%n(a8^AFc@>^&x@=1x zaV|0ErY8L2KMTntYA2T5v>6=V6dr1~B{$s`y#a~6c<3!#aud#38l=X? z%8k!luAlgB=c8*zE*w05cpL`H_=SlQ4hKM}IT*;N2I%9-d~w><{m zJmxYt%*5w*+2l$vE6iH-9~SDS4xOPw^~sMA&&AKPgEhte+G6zF^osHsaD%a);@R#Q zPCE%td-f)#<|6Hvgi`$HzTa?Gxp7etwnV2e7=p?rW));A7kV(D#xPZ57UfZs`bm!Zp!Zlpx!4dr~o8yuo!v-J~9_a~Ud62>2UAQWN-k&2j!8Qv9_A|(d( z7v5`$DgQTwGgIN>9bnjQ)~<+9C5R?$sQjN2yp~U$b=aOIY>3N5Cu>nHMTxRv+~K>l zjG3U0L{Hzg#I|8o8R<2X%E<1dZghkxagB}|d0XWfok>Hr)!yNPnaUl|J~mp~r{%-3 HDsAL{Y`0zO literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/vc120.idb b/zlib/src/Debug/vc120.idb new file mode 100644 index 0000000000000000000000000000000000000000..151183e37338299c0cb6b202c1cc4570ff6c6946 GIT binary patch literal 84992 zcmeI54Uk+_mB)J|VUdM3A}+{>P7)vqIGK+O`GP<`W|9mfG3LXhbe3V#(@BQRS9Q-M zB)G^bh?I)3#uB#NEmp*(1l=kNDN)y@ENWS^0fYsMDrFH3er&B})GV@!X8*tY-kEv* zraS$nyC=yc_tu=b@7;I$zH`sJALpKP?!BwK)7k!9|JK3UW%bK0yR3Hg`sKCrW;ZmP zdHQ)R>r)DoQmHp7;`)&q5>lz@LFE5?4tNesa1Q+Zl+?LzKL3h;4ucn)|DoMaqG z{ZOO3+W##lS-E|2JqJ7o4j*n=x4!n^n^UPjh#817wSrxnF5JZR6v5=n?mu|eo_m+x zdESm6-}umNyGfrfxK1FcA@%4Bz3Z<2^aro3|Kqb~>Ndp`0btIM`fTIgw+!sB+5R?e zQmMNItpf5T+^P2hnqs8>>486e9oq0eqoGadfWxi(@Z?=D@2hzzoaY#_d#0O5 zRA9ip=d6b|Uw6q0Fze}>Q`>@P;MSk2G6%P*H|Yg{qp9WKV;@l2ZofHv7)DmM3*M4S0S@

IHzi-}>N9KUw@# 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 literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/vc120.pdb b/zlib/src/Debug/vc120.pdb new file mode 100644 index 0000000000000000000000000000000000000000..6ec771744b44a595a6f4746b4c14627bc6e35248 GIT binary patch literal 86016 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 literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/zlib.log b/zlib/src/Debug/zlib.log new file mode 100644 index 0000000..273708d --- /dev/null +++ b/zlib/src/Debug/zlib.log @@ -0,0 +1,74 @@ +Build started 25.04.2016 2:32:04. + 1>Project "D:\Documents\Visual Studio 2013\Projects\scetool\zlib\src\zlib.vcxproj" on node 2 (Build target(s)). + 1>ClCompile: + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\CL.exe /c /Zi /nologo /W3 /WX- /Od /Oy- /D WIN32 /D _DEBUG /D _LIB /D _USING_V110_SDK71_ /Gm /EHsc /RTC1 /MTd /GS /fp:precise /Zc:wchar_t /Zc:forScope /Fo"Debug\\" /Fd"Debug\vc120.pdb" /Gd /TC /analyze- /errorReport:prompt adler32.c compress.c crc32.c deflate.c gzclose.c gzlib.c gzread.c gzwrite.c infback.c inffast.c inflate.c inftrees.c trees.c uncompr.c zutil.c + zutil.c + uncompr.c + trees.c + inftrees.c + inflate.c + inffast.c + infback.c + gzwrite.c + 1>gzwrite.c(84): warning C4996: 'write': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _write. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(342) : see declaration of 'write' + 1>gzwrite.c(86): warning C4996: 'strerror': This function or variable may be unsafe. Consider using strerror_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\string.h(168) : see declaration of 'strerror' + 1>gzwrite.c(102): warning C4996: 'write': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _write. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(342) : see declaration of 'write' + 1>gzwrite.c(103): warning C4996: 'strerror': This function or variable may be unsafe. Consider using strerror_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\string.h(168) : see declaration of 'strerror' + 1>gzwrite.c(357): warning C4996: 'vsnprintf': This function or variable may be unsafe. Consider using vsnprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdio.h(337) : see declaration of 'vsnprintf' + 1>gzwrite.c(573): warning C4996: 'close': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _close. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(326) : see declaration of 'close' + gzread.c + 1>gzread.c(30): warning C4996: 'read': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _read. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(337) : see declaration of 'read' + 1>gzread.c(36): warning C4996: 'strerror': This function or variable may be unsafe. Consider using strerror_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\string.h(168) : see declaration of 'strerror' + 1>gzread.c(591): warning C4996: 'close': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _close. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(326) : see declaration of 'close' + gzlib.c + 1>gzlib.c(193): warning C4996: 'wcstombs': This function or variable may be unsafe. Consider using wcstombs_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdlib.h(575) : see declaration of 'wcstombs' + 1>gzlib.c(208): warning C4996: 'wcstombs': This function or variable may be unsafe. Consider using wcstombs_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdlib.h(575) : see declaration of 'wcstombs' + 1>gzlib.c(214): warning C4996: '_snprintf': This function or variable may be unsafe. Consider using _snprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdio.h(346) : see declaration of '_snprintf' + 1>gzlib.c(245): warning C4996: '_wopen': This function or variable may be unsafe. Consider using _wsopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(274) : see declaration of '_wopen' + 1>gzlib.c(245): warning C4996: 'open': The POSIX name for this item is deprecated. Instead, use the ISO C++ conformant name: _open. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\io.h(336) : see declaration of 'open' + 1>gzlib.c(294): warning C4996: '_snprintf': This function or variable may be unsafe. Consider using _snprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdio.h(346) : see declaration of '_snprintf' + 1>gzlib.c(608): warning C4996: '_snprintf': This function or variable may be unsafe. Consider using _snprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\stdio.h(346) : see declaration of '_snprintf' + gzclose.c + deflate.c + crc32.c + compress.c + adler32.c + Generating Code... + Lib: + C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\Lib.exe /OUT:"D:\Documents\Visual Studio 2013\Projects\scetool\zlib\src\Debug\zlibd.lib" /NOLOGO Debug\adler32.obj + Debug\compress.obj + Debug\crc32.obj + Debug\deflate.obj + Debug\gzclose.obj + Debug\gzlib.obj + Debug\gzread.obj + Debug\gzwrite.obj + Debug\infback.obj + Debug\inffast.obj + Debug\inflate.obj + Debug\inftrees.obj + Debug\trees.obj + Debug\uncompr.obj + Debug\zutil.obj + zlib.vcxproj -> D:\Documents\Visual Studio 2013\Projects\scetool\zlib\src\Debug\zlibd.lib + 1>Done Building Project "D:\Documents\Visual Studio 2013\Projects\scetool\zlib\src\zlib.vcxproj" (Build target(s)). + +Build succeeded. + +Time Elapsed 00:00:03.24 diff --git a/zlib/src/Debug/zlib.tlog/CL.read.1.tlog b/zlib/src/Debug/zlib.tlog/CL.read.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..d2e0a73dcaf3afd5f4e901759641880aa176b80f GIT binary patch literal 35382 zcmeHQU2hUm5S?ce{{xTu(pXK5@vU8U5v5>QXf0{{|Gz>#=U&$Z3VShvGY=?Coe! zd#<5BSI{8p81-R_zg^*-sb4i7QzCp%>S2r(@xNQ8)iq(()TU2n6!}npXhD|vq7A9+ z5t5?qh_S+ZtcBVYY5yppC+O89tSCQKF(gGxKZdlHHVL(&ynAtEv`ls@mW=#;$prp> z0y_}Lc4vJiZi%8h4+%BV>#dT{<<%@95MRIBz-n_%QEYacJ*$&nn{Vlm4{}~7&$<9Q zA~y3y&;GV%1AP^49YWH=t;3N<)*s>4?byB)owW(s3%8EIfDCI_MjpGk)yHqFQdE{> z3_r#tOJauDVug68Lu1|ylqc^ZA1dzW5WiZsEOD3>`OxS5czOTC{p3tSSyE)9c73RC zluWNK?&nZmXB%Z?uj+$#=u?=5AQSD4c{Yg)%egKg4MppU){keEOTIuzLrCLtS?5F1 zx{$_hWJlokKNi{eYrwlohR*k*~P~llL@=UBk*zTNPI{Yd%5b|kB?Jtq%e>$ z(Epw$(c;rjk4a0t-*4*^35gHqUc{dGA?{M#bO$Jl{&7XbzJ%MR5M>#;lxi`R6m@d`G%Trcxqj` zGTbHfqxpv7e8l;vpL*N3=g8d)V{|7Q^3(>NhwF(nx+*qLE<+J~$%iR|R|J3F)92Os zc`Cv_l-Kd`9PE*sp>|`b2o*lFKbuJtzxqlR`g2yi#yOc>5o*c1D?(L-st7e!g!&6K CvhAz@ literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/zlib.tlog/CL.write.1.tlog b/zlib/src/Debug/zlib.tlog/CL.write.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..6a5f960d76f69647c6f00ad4a383e7abfae842fe GIT binary patch literal 8964 zcmeI2O>ToQ5JqQRsdwlJq9)ySM+`)yq*VN*QWW(hJ$us6P&C%m>UL%^iUf`Y=;e99 zpHc3&FDmJkuGn@IXrdEU^iCrU=sQz`{X_+|^n})kc8R_Y-*)s&TYAA!AJn7gi1Whl zc>`J%+8sVEj<{gk&>pP;#|G>RT&Kk`J+82$4f?)SI06Vy^Dn5tHmH(BGrBfPj7W`f zDKK`GqKgA6CV->Eh-h;xm8(~w(M1mn@s81@_yk9zTp10XO*Nh*1?uBX(Z|A3gCjl_ z^~Po4(7$6Bj&ZKk_$1XcVu4{omGaD@=i-9-dc-~3&g1b&4=QtPoK^N9IbhyD!^?Kg z4jat6CHk#VHD;(}M(SYeXu=oQ_L`b3v2l*FLnV`y9Wt4}<$%N7;qF*lsCkyHaCls zhB#)#y%O?OP4*RVMIxxim3Df(~^eRN+8m7$mO0VNFMW&IgKb?#^zB-^L25Ln3i{Gu?K}xBKWo4v5cFKTrZKT0AS4Rp|%lb%xY*`_xkezEJ6{@*P zQsKJPNeX1?gqCu6U_#Q)4DIA{XL{-Dc~`2v zZj6nb2Gz=RQm>BKMJ4l~Sd~^-J$6d0!HcxfRy$Um)ezTUzdTqGlk5vXp1dh(VRNQ)IBrARYCVT za5YrW8m@3E>~y^6s)Z$gB5k3%f~z#vStUA|qg65ebu`3Rz?Fl`E4H0F23+yS@1!^eyhq*rY2-HYp((N^NVQ)=&khf4usgnU$v5yicKr zuyZ*%Gka$D%QsSlYTA3ORRp?X`jgd{&CvVi#K(8rHDCfv(YDYTIq28kP zNh2g5X_vL_#*_-mHJjxtkJ8H|&w$itd7y6(dt;Hioo1tNS4Jk*fD%zUlN-Li6O82@%|AtnVK|ZH;tY4&G zbK4Aq|xcE276URQH73b2jYMz literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/zlib.tlog/lib.command.1.tlog b/zlib/src/Debug/zlib.tlog/lib.command.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..55d972b8760d76f45942967d928afdebdb6c4ef3 GIT binary patch literal 2950 zcmd6pO-{ow5QX0wi94VkfI``Im)|OoVw4|{D#S@RJMg&y>evx1JBpNy?Pu#{X8dM8 zKi*Vot5@Dmg+}dF=~07v=APB?9hIro71n@VGUpg=bfa6{fqGKM%su;x?|nU1h3$A+ z5C`6ka;zR~!M9{R=d>Mm#;9f7aoR@L?8!Opo!Rs9Dqyld{#^y{-V`(MMO)tT5v_@1 zM%*hyzS@y}1-u*)w8m??6?QV-`>MlB{zlqj^#ZTPSY|coWQ|s3-}qhXLThy2&u_Ildq45h1$k|q zlz&AZwZ@;mOLFu=zOVYfGYS!>NX&bbIVSEF!c}jlbvr~XSI`(SuVwLSTvg)rRNq6y dveKrASo2autUf6sy>lVv@73kI5$<2k(l4XJu7m&p literal 0 HcmV?d00001 diff --git a/zlib/src/Debug/zlib.tlog/zlib.lastbuildstate b/zlib/src/Debug/zlib.tlog/zlib.lastbuildstate new file mode 100644 index 0000000..1286ba6 --- /dev/null +++ b/zlib/src/Debug/zlib.tlog/zlib.lastbuildstate @@ -0,0 +1,2 @@ +#TargetFrameworkVersion=v4.0:PlatformToolSet=v120_xp:EnableManagedIncrementalBuild=false:VCToolArchitecture=Native32Bit +Debug|Win32|D:\Documents\Visual Studio 2013\Projects\scetool\zlib\src\| diff --git a/zlib/src/Debug/zlibd.lib b/zlib/src/Debug/zlibd.lib new file mode 100644 index 0000000000000000000000000000000000000000..f0afd552db4264046719bb08de0a6b8be2fb70a2 GIT binary patch literal 241282 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

~%AM5{*21LxKb{WFQ2VB}-y0$od+Ce1GE zu#5|BhP8%>9PIHq=Y-NMz(0I+}f$jbrjcwPK zw*KLBn99tK_u z%znd%+y&ruz#jMwUvl3D#*3WeTp7T{`LBdL1LvEecn$3Z@9LubvkuQ|1zL$M{{dZ3 z>ff+@<{<057T^mhx-OOz`;J@`fbDb6?Q7|7_|E+SV1DjB|0NdWS3sGCi(|P9{A-G0 zVI8)+3~i<@7C9V`C*^MlrrZj~iR>j);af6_SXKP|44P^vi8RfH5F2JrTFolv8^keV z9t*&JaLhapS6kc$hZ*xK;41J|1GAq^z{T^(>yv?V%TOFUZ|24G$T}SRT(nYq>@i(Y z{{PT#R7}1G6tJz$3u3ux6|1lJd0$-?AaBnMAq=ucNEH z5^T&-IIgH#EE!50dPX*&;40_+D`oWRN;sN`$UI7Oz+M8I`{mxS9x`Y#`b`isr6$Z+ zRxZIX$I+Kmqp28X)m83+bjTEheg!zqrUSYXlam?E5YI@lQaBV>(+07T{H#NTJ+oBc zb3v;NY~F)1ZAq<12ze*m$Mb~yGzy7Nkq`XH>$q<5UFBEa``4|j>Xskhyr?Nebfe(^ zYvJ$LxE}aw+p~{+(|I zZa%K9HWr-Cs2Ju4z2F<>)PU z4-q{h_($*V%B}p&_si|izB2di;oGs8M+ATTT=(xT-8r~-Y}fAFUJLyg8&f?B39sYE z9jU67^4X^T`?kFN{V!*B6CD!#@u%fKJ4d@b;}7Hlzc_OU8{8SeFB$vy%i-@WdT__< z?_H=`HvS3GY%E-_Bl_Xf^E@AH{W4H<=h-)(zYH747QuI)`_r+&g#%~L9oUN^Vm`AVUvsX_4 zZT@u&W{p3#X4R(W{<4KABKXhU^zPYxve(%CowrA>7;#~epBMc5Lu>!2d3QZ_$)4Xn zy1wG00MS>1@0Oo^zjEsnr;a_;@zj%NZ}^C4!%Vinb8swq>&izHnYC-y|MQW^0-`T4 zFQ+j^a&s`HCwug8LW<%0pO$J4G&L>{CJJ>zpIL~c%|fKM&gT#I$w5_<V(<)u8;sYZ^YN^BY;+Mm)@&4~F_Ek1>%V@5TV#m6=6)DkNvwP{F59Hsnp zyacjtV1lM&?S`jeXFzV`jIJx1d@wy7_WHup6r6$8$1l_rH&7HB8gDt(oqnlWiKL`; zKx#_jeuK0^`hj48&kVDZHakriT_<4+=Ng9Vu~KR)ufjL|XP_6M&7xt8@`&#`^W5ae z7n3Ouq3#oun|eVl78=Jb%0nkC%1thO8+p`2WftY8&p}-#G#c<_W6DEK7UiZ}3p_5S zdDKnEK`jv)TzoR+p%RO76W22)&nWPI1!}3#7_%r3if5DOrd<~0p?0fQU9j)71J52gi14PcZHVg@(POA&>TT=c`d4SRHUdM1dmTk<$~hc zn$Je1V)cAWP!j%GqLixf&!>n|>KYh20fP3t_Lczj4-ZwIV7fmr)E^k`4~+H)&i4n# z&IHC-@J!%5CYlc4c7BF22md988~-k2?%=$^%Lf8uhfg{nJXkrj z=l9=_la|S`-$%kIIURn>#ssq8MRGoz4!(`#8^{T;-$P)by~MrT0(}7q8BP$DTM5IprSMBGBFg|(YZ0Su~(7z1=1-pyPGxD*bq)DR=1-! UV?>ktwW85NOr}y^s^Ij00Ds+b5dZ)H literal 0 HcmV?d00001 diff --git a/zlib/src/FAQ b/zlib/src/FAQ new file mode 100644 index 0000000..99b7cf9 --- /dev/null +++ b/zlib/src/FAQ @@ -0,0 +1,368 @@ + + Frequently Asked Questions about zlib + + +If your question is not there, please check the zlib home page +http://zlib.net/ which may have more recent information. +The lastest zlib FAQ is at http://zlib.net/zlib_faq.html + + + 1. Is zlib Y2K-compliant? + + Yes. zlib doesn't handle dates. + + 2. Where can I get a Windows DLL version? + + The zlib sources can be compiled without change to produce a DLL. See the + file win32/DLL_FAQ.txt in the zlib distribution. Pointers to the + precompiled DLL are found in the zlib web site at http://zlib.net/ . + + 3. Where can I get a Visual Basic interface to zlib? + + See + * http://marknelson.us/1997/01/01/zlib-engine/ + * win32/DLL_FAQ.txt in the zlib distribution + + 4. compress() returns Z_BUF_ERROR. + + Make sure that before the call of compress(), the length of the compressed + buffer is equal to the available size of the compressed buffer and not + zero. For Visual Basic, check that this parameter is passed by reference + ("as any"), not by value ("as long"). + + 5. deflate() or inflate() returns Z_BUF_ERROR. + + Before making the call, make sure that avail_in and avail_out are not zero. + When setting the parameter flush equal to Z_FINISH, also make sure that + avail_out is big enough to allow processing all pending input. Note that a + Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be + made with more input or output space. A Z_BUF_ERROR may in fact be + unavoidable depending on how the functions are used, since it is not + possible to tell whether or not there is more output pending when + strm.avail_out returns with zero. See http://zlib.net/zlib_how.html for a + heavily annotated example. + + 6. Where's the zlib documentation (man pages, etc.)? + + It's in zlib.h . Examples of zlib usage are in the files test/example.c + and test/minigzip.c, with more in examples/ . + + 7. Why don't you use GNU autoconf or libtool or ...? + + Because we would like to keep zlib as a very small and simple package. + zlib is rather portable and doesn't need much configuration. + + 8. I found a bug in zlib. + + Most of the time, such problems are due to an incorrect usage of zlib. + Please try to reproduce the problem with a small program and send the + corresponding source to us at zlib@gzip.org . Do not send multi-megabyte + data files without prior agreement. + + 9. Why do I get "undefined reference to gzputc"? + + If "make test" produces something like + + example.o(.text+0x154): undefined reference to `gzputc' + + check that you don't have old files libz.* in /usr/lib, /usr/local/lib or + /usr/X11R6/lib. Remove any old versions, then do "make install". + +10. I need a Delphi interface to zlib. + + See the contrib/delphi directory in the zlib distribution. + +11. Can zlib handle .zip archives? + + Not by itself, no. See the directory contrib/minizip in the zlib + distribution. + +12. Can zlib handle .Z files? + + No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt + the code of uncompress on your own. + +13. How can I make a Unix shared library? + + By default a shared (and a static) library is built for Unix. So: + + make distclean + ./configure + make + +14. How do I install a shared zlib library on Unix? + + After the above, then: + + make install + + However, many flavors of Unix come with a shared zlib already installed. + Before going to the trouble of compiling a shared version of zlib and + trying to install it, you may want to check if it's already there! If you + can #include , it's there. The -lz option will probably link to + it. You can check the version at the top of zlib.h or with the + ZLIB_VERSION symbol defined in zlib.h . + +15. I have a question about OttoPDF. + + We are not the authors of OttoPDF. The real author is on the OttoPDF web + site: Joel Hainley, jhainley@myndkryme.com. + +16. Can zlib decode Flate data in an Adobe PDF file? + + Yes. See http://www.pdflib.com/ . To modify PDF forms, see + http://sourceforge.net/projects/acroformtool/ . + +17. Why am I getting this "register_frame_info not found" error on Solaris? + + After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib + generates an error such as: + + ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so: + symbol __register_frame_info: referenced symbol not found + + The symbol __register_frame_info is not part of zlib, it is generated by + the C compiler (cc or gcc). You must recompile applications using zlib + which have this problem. This problem is specific to Solaris. See + http://www.sunfreeware.com for Solaris versions of zlib and applications + using zlib. + +18. Why does gzip give an error on a file I make with compress/deflate? + + The compress and deflate functions produce data in the zlib format, which + is different and incompatible with the gzip format. The gz* functions in + zlib on the other hand use the gzip format. Both the zlib and gzip formats + use the same compressed data format internally, but have different headers + and trailers around the compressed data. + +19. Ok, so why are there two different formats? + + The gzip format was designed to retain the directory information about a + single file, such as the name and last modification date. The zlib format + on the other hand was designed for in-memory and communication channel + applications, and has a much more compact header and trailer and uses a + faster integrity check than gzip. + +20. Well that's nice, but how do I make a gzip file in memory? + + You can request that deflate write the gzip format instead of the zlib + format using deflateInit2(). You can also request that inflate decode the + gzip format using inflateInit2(). Read zlib.h for more details. + +21. Is zlib thread-safe? + + Yes. However any library routines that zlib uses and any application- + provided memory allocation routines must also be thread-safe. zlib's gz* + functions use stdio library routines, and most of zlib's functions use the + library memory allocation routines by default. zlib's *Init* functions + allow for the application to provide custom memory allocation routines. + + Of course, you should only operate on any given zlib or gzip stream from a + single thread at a time. + +22. Can I use zlib in my commercial application? + + Yes. Please read the license in zlib.h. + +23. Is zlib under the GNU license? + + No. Please read the license in zlib.h. + +24. The license says that altered source versions must be "plainly marked". So + what exactly do I need to do to meet that requirement? + + You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In + particular, the final version number needs to be changed to "f", and an + identification string should be appended to ZLIB_VERSION. Version numbers + x.x.x.f are reserved for modifications to zlib by others than the zlib + maintainers. For example, if the version of the base zlib you are altering + is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and + ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also + update the version strings in deflate.c and inftrees.c. + + For altered source distributions, you should also note the origin and + nature of the changes in zlib.h, as well as in ChangeLog and README, along + with the dates of the alterations. The origin should include at least your + name (or your company's name), and an email address to contact for help or + issues with the library. + + Note that distributing a compiled zlib library along with zlib.h and + zconf.h is also a source distribution, and so you should change + ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes + in zlib.h as you would for a full source distribution. + +25. Will zlib work on a big-endian or little-endian architecture, and can I + exchange compressed data between them? + + Yes and yes. + +26. Will zlib work on a 64-bit machine? + + Yes. It has been tested on 64-bit machines, and has no dependence on any + data types being limited to 32-bits in length. If you have any + difficulties, please provide a complete problem report to zlib@gzip.org + +27. Will zlib decompress data from the PKWare Data Compression Library? + + No. The PKWare DCL uses a completely different compressed data format than + does PKZIP and zlib. However, you can look in zlib's contrib/blast + directory for a possible solution to your problem. + +28. Can I access data randomly in a compressed stream? + + No, not without some preparation. If when compressing you periodically use + Z_FULL_FLUSH, carefully write all the pending data at those points, and + keep an index of those locations, then you can start decompression at those + points. You have to be careful to not use Z_FULL_FLUSH too often, since it + can significantly degrade compression. Alternatively, you can scan a + deflate stream once to generate an index, and then use that index for + random access. See examples/zran.c . + +29. Does zlib work on MVS, OS/390, CICS, etc.? + + It has in the past, but we have not heard of any recent evidence. There + were working ports of zlib 1.1.4 to MVS, but those links no longer work. + If you know of recent, successful applications of zlib on these operating + systems, please let us know. Thanks. + +30. Is there some simpler, easier to read version of inflate I can look at to + understand the deflate format? + + First off, you should read RFC 1951. Second, yes. Look in zlib's + contrib/puff directory. + +31. Does zlib infringe on any patents? + + As far as we know, no. In fact, that was originally the whole point behind + zlib. Look here for some more information: + + http://www.gzip.org/#faq11 + +32. Can zlib work with greater than 4 GB of data? + + Yes. inflate() and deflate() will process any amount of data correctly. + Each call of inflate() or deflate() is limited to input and output chunks + of the maximum value that can be stored in the compiler's "unsigned int" + type, but there is no limit to the number of chunks. Note however that the + strm.total_in and strm_total_out counters may be limited to 4 GB. These + counters are provided as a convenience and are not used internally by + inflate() or deflate(). The application can easily set up its own counters + updated after each call of inflate() or deflate() to count beyond 4 GB. + compress() and uncompress() may be limited to 4 GB, since they operate in a + single call. gzseek() and gztell() may be limited to 4 GB depending on how + zlib is compiled. See the zlibCompileFlags() function in zlib.h. + + The word "may" appears several times above since there is a 4 GB limit only + if the compiler's "long" type is 32 bits. If the compiler's "long" type is + 64 bits, then the limit is 16 exabytes. + +33. Does zlib have any security vulnerabilities? + + The only one that we are aware of is potentially in gzprintf(). If zlib is + compiled to use sprintf() or vsprintf(), then there is no protection + against a buffer overflow of an 8K string space (or other value as set by + gzbuffer()), other than the caller of gzprintf() assuring that the output + will not exceed 8K. On the other hand, if zlib is compiled to use + snprintf() or vsnprintf(), which should normally be the case, then there is + no vulnerability. The ./configure script will display warnings if an + insecure variation of sprintf() will be used by gzprintf(). Also the + zlibCompileFlags() function will return information on what variant of + sprintf() is used by gzprintf(). + + If you don't have snprintf() or vsnprintf() and would like one, you can + find a portable implementation here: + + http://www.ijs.si/software/snprintf/ + + Note that you should be using the most recent version of zlib. Versions + 1.1.3 and before were subject to a double-free vulnerability, and versions + 1.2.1 and 1.2.2 were subject to an access exception when decompressing + invalid compressed data. + +34. Is there a Java version of zlib? + + Probably what you want is to use zlib in Java. zlib is already included + as part of the Java SDK in the java.util.zip package. If you really want + a version of zlib written in the Java language, look on the zlib home + page for links: http://zlib.net/ . + +35. I get this or that compiler or source-code scanner warning when I crank it + up to maximally-pedantic. Can't you guys write proper code? + + Many years ago, we gave up attempting to avoid warnings on every compiler + in the universe. It just got to be a waste of time, and some compilers + were downright silly as well as contradicted each other. So now, we simply + make sure that the code always works. + +36. Valgrind (or some similar memory access checker) says that deflate is + performing a conditional jump that depends on an uninitialized value. + Isn't that a bug? + + No. That is intentional for performance reasons, and the output of deflate + is not affected. This only started showing up recently since zlib 1.2.x + uses malloc() by default for allocations, whereas earlier versions used + calloc(), which zeros out the allocated memory. Even though the code was + correct, versions 1.2.4 and later was changed to not stimulate these + checkers. + +37. Will zlib read the (insert any ancient or arcane format here) compressed + data format? + + Probably not. Look in the comp.compression FAQ for pointers to various + formats and associated software. + +38. How can I encrypt/decrypt zip files with zlib? + + zlib doesn't support encryption. The original PKZIP encryption is very + weak and can be broken with freely available programs. To get strong + encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib + compression. For PKZIP compatible "encryption", look at + http://www.info-zip.org/ + +39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings? + + "gzip" is the gzip format, and "deflate" is the zlib format. They should + probably have called the second one "zlib" instead to avoid confusion with + the raw deflate compressed data format. While the HTTP 1.1 RFC 2616 + correctly points to the zlib specification in RFC 1950 for the "deflate" + transfer encoding, there have been reports of servers and browsers that + incorrectly produce or expect raw deflate data per the deflate + specification in RFC 1951, most notably Microsoft. So even though the + "deflate" transfer encoding using the zlib format would be the more + efficient approach (and in fact exactly what the zlib format was designed + for), using the "gzip" transfer encoding is probably more reliable due to + an unfortunate choice of name on the part of the HTTP 1.1 authors. + + Bottom line: use the gzip format for HTTP 1.1 encoding. + +40. Does zlib support the new "Deflate64" format introduced by PKWare? + + No. PKWare has apparently decided to keep that format proprietary, since + they have not documented it as they have previous compression formats. In + any case, the compression improvements are so modest compared to other more + modern approaches, that it's not worth the effort to implement. + +41. I'm having a problem with the zip functions in zlib, can you help? + + There are no zip functions in zlib. You are probably using minizip by + Giles Vollant, which is found in the contrib directory of zlib. It is not + part of zlib. In fact none of the stuff in contrib is part of zlib. The + files in there are not supported by the zlib authors. You need to contact + the authors of the respective contribution for help. + +42. The match.asm code in contrib is under the GNU General Public License. + Since it's part of zlib, doesn't that mean that all of zlib falls under the + GNU GPL? + + No. The files in contrib are not part of zlib. They were contributed by + other authors and are provided as a convenience to the user within the zlib + distribution. Each item in contrib has its own license. + +43. Is zlib subject to export controls? What is its ECCN? + + zlib is not subject to export controls, and so is classified as EAR99. + +44. Can you please sign these lengthy legal documents and fax them back to us + so that we can use your software in our product? + + No. Go away. Shoo. diff --git a/zlib/src/INDEX b/zlib/src/INDEX new file mode 100644 index 0000000..2ba0641 --- /dev/null +++ b/zlib/src/INDEX @@ -0,0 +1,68 @@ +CMakeLists.txt cmake build file +ChangeLog history of changes +FAQ Frequently Asked Questions about zlib +INDEX this file +Makefile dummy Makefile that tells you to ./configure +Makefile.in template for Unix Makefile +README guess what +configure configure script for Unix +make_vms.com makefile for VMS +test/example.c zlib usages examples for build testing +test/minigzip.c minimal gzip-like functionality for build testing +test/infcover.c inf*.c code coverage for build coverage testing +treebuild.xml XML description of source file dependencies +zconf.h.cmakein zconf.h template for cmake +zconf.h.in zconf.h template for configure +zlib.3 Man page for zlib +zlib.3.pdf Man page in PDF format +zlib.map Linux symbol information +zlib.pc.in Template for pkg-config descriptor +zlib.pc.cmakein zlib.pc template for cmake +zlib2ansi perl script to convert source files for C++ compilation + +amiga/ makefiles for Amiga SAS C +as400/ makefiles for AS/400 +doc/ documentation for formats and algorithms +msdos/ makefiles for MSDOS +nintendods/ makefile for Nintendo DS +old/ makefiles for various architectures and zlib documentation + files that have not yet been updated for zlib 1.2.x +qnx/ makefiles for QNX +watcom/ makefiles for OpenWatcom +win32/ makefiles for Windows + + zlib public header files (required for library use): +zconf.h +zlib.h + + private source files used to build the zlib library: +adler32.c +compress.c +crc32.c +crc32.h +deflate.c +deflate.h +gzclose.c +gzguts.h +gzlib.c +gzread.c +gzwrite.c +infback.c +inffast.c +inffast.h +inffixed.h +inflate.c +inflate.h +inftrees.c +inftrees.h +trees.c +trees.h +uncompr.c +zutil.c +zutil.h + + source files for sample programs +See examples/README.examples + + unsupported contributions by third parties +See contrib/README.contrib diff --git a/zlib/src/Makefile b/zlib/src/Makefile new file mode 100644 index 0000000..6bba86c --- /dev/null +++ b/zlib/src/Makefile @@ -0,0 +1,5 @@ +all: + -@echo "Please use ./configure first. Thank you." + +distclean: + make -f Makefile.in distclean diff --git a/zlib/src/Makefile.in b/zlib/src/Makefile.in new file mode 100644 index 0000000..c61aa30 --- /dev/null +++ b/zlib/src/Makefile.in @@ -0,0 +1,288 @@ +# Makefile for zlib +# Copyright (C) 1995-2013 Jean-loup Gailly, Mark Adler +# For conditions of distribution and use, see copyright notice in zlib.h + +# To compile and test, type: +# ./configure; make test +# Normally configure builds both a static and a shared library. +# If you want to build just a static library, use: ./configure --static + +# To use the asm code, type: +# cp contrib/asm?86/match.S ./match.S +# make LOC=-DASMV OBJA=match.o + +# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type: +# make install +# To install in $HOME instead of /usr/local, use: +# make install prefix=$HOME + +CC=cc + +CFLAGS=-O +#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 +#CFLAGS=-g -DDEBUG +#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ +# -Wstrict-prototypes -Wmissing-prototypes + +SFLAGS=-O +LDFLAGS= +TEST_LDFLAGS=-L. libz.a +LDSHARED=$(CC) +CPP=$(CC) -E + +STATICLIB=libz.a +SHAREDLIB=libz.so +SHAREDLIBV=libz.so.1.2.8 +SHAREDLIBM=libz.so.1 +LIBS=$(STATICLIB) $(SHAREDLIBV) + +AR=ar +ARFLAGS=rc +RANLIB=ranlib +LDCONFIG=ldconfig +LDSHAREDLIBC=-lc +TAR=tar +SHELL=/bin/sh +EXE= + +prefix = /usr/local +exec_prefix = ${prefix} +libdir = ${exec_prefix}/lib +sharedlibdir = ${libdir} +includedir = ${prefix}/include +mandir = ${prefix}/share/man +man3dir = ${mandir}/man3 +pkgconfigdir = ${libdir}/pkgconfig + +OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o +OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o +OBJC = $(OBJZ) $(OBJG) + +PIC_OBJZ = adler32.lo crc32.lo deflate.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo zutil.lo +PIC_OBJG = compress.lo uncompr.lo gzclose.lo gzlib.lo gzread.lo gzwrite.lo +PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG) + +# to use the asm code: make OBJA=match.o, PIC_OBJA=match.lo +OBJA = +PIC_OBJA = + +OBJS = $(OBJC) $(OBJA) + +PIC_OBJS = $(PIC_OBJC) $(PIC_OBJA) + +all: static shared + +static: example$(EXE) minigzip$(EXE) + +shared: examplesh$(EXE) minigzipsh$(EXE) + +all64: example64$(EXE) minigzip64$(EXE) + +check: test + +test: all teststatic testshared + +teststatic: static + @TMPST=tmpst_$$; \ + if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \ + echo ' *** zlib test OK ***'; \ + else \ + echo ' *** zlib test FAILED ***'; false; \ + fi; \ + rm -f $$TMPST + +testshared: shared + @LD_LIBRARY_PATH=`pwd`:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \ + LD_LIBRARYN32_PATH=`pwd`:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \ + DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \ + SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \ + TMPSH=tmpsh_$$; \ + if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \ + echo ' *** zlib shared test OK ***'; \ + else \ + echo ' *** zlib shared test FAILED ***'; false; \ + fi; \ + rm -f $$TMPSH + +test64: all64 + @TMP64=tmp64_$$; \ + if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \ + echo ' *** zlib 64-bit test OK ***'; \ + else \ + echo ' *** zlib 64-bit test FAILED ***'; false; \ + fi; \ + rm -f $$TMP64 + +infcover.o: test/infcover.c zlib.h zconf.h + $(CC) $(CFLAGS) -I. -c -o $@ test/infcover.c + +infcover: infcover.o libz.a + $(CC) $(CFLAGS) -o $@ infcover.o libz.a + +cover: infcover + rm -f *.gcda + ./infcover + gcov inf*.c + +libz.a: $(OBJS) + $(AR) $(ARFLAGS) $@ $(OBJS) + -@ ($(RANLIB) $@ || true) >/dev/null 2>&1 + +match.o: match.S + $(CPP) match.S > _match.s + $(CC) -c _match.s + mv _match.o match.o + rm -f _match.s + +match.lo: match.S + $(CPP) match.S > _match.s + $(CC) -c -fPIC _match.s + mv _match.o match.lo + rm -f _match.s + +example.o: test/example.c zlib.h zconf.h + $(CC) $(CFLAGS) -I. -c -o $@ test/example.c + +minigzip.o: test/minigzip.c zlib.h zconf.h + $(CC) $(CFLAGS) -I. -c -o $@ test/minigzip.c + +example64.o: test/example.c zlib.h zconf.h + $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/example.c + +minigzip64.o: test/minigzip.c zlib.h zconf.h + $(CC) $(CFLAGS) -I. -D_FILE_OFFSET_BITS=64 -c -o $@ test/minigzip.c + +.SUFFIXES: .lo + +.c.lo: + -@mkdir objs 2>/dev/null || test -d objs + $(CC) $(SFLAGS) -DPIC -c -o objs/$*.o $< + -@mv objs/$*.o $@ + +placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a + $(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS) + rm -f $(SHAREDLIB) $(SHAREDLIBM) + ln -s $@ $(SHAREDLIB) + ln -s $@ $(SHAREDLIBM) + -@rmdir objs + +example$(EXE): example.o $(STATICLIB) + $(CC) $(CFLAGS) -o $@ example.o $(TEST_LDFLAGS) + +minigzip$(EXE): minigzip.o $(STATICLIB) + $(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS) + +examplesh$(EXE): example.o $(SHAREDLIBV) + $(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDLIBV) + +minigzipsh$(EXE): minigzip.o $(SHAREDLIBV) + $(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDLIBV) + +example64$(EXE): example64.o $(STATICLIB) + $(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS) + +minigzip64$(EXE): minigzip64.o $(STATICLIB) + $(CC) $(CFLAGS) -o $@ minigzip64.o $(TEST_LDFLAGS) + +install-libs: $(LIBS) + -@if [ ! -d $(DESTDIR)$(exec_prefix) ]; then mkdir -p $(DESTDIR)$(exec_prefix); fi + -@if [ ! -d $(DESTDIR)$(libdir) ]; then mkdir -p $(DESTDIR)$(libdir); fi + -@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi + -@if [ ! -d $(DESTDIR)$(man3dir) ]; then mkdir -p $(DESTDIR)$(man3dir); fi + -@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi + cp $(STATICLIB) $(DESTDIR)$(libdir) + chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB) + -@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1 + -@if test -n "$(SHAREDLIBV)"; then \ + cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \ + echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \ + chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \ + echo "chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV)"; \ + rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \ + ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB); \ + ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \ + ($(LDCONFIG) || true) >/dev/null 2>&1; \ + fi + cp zlib.3 $(DESTDIR)$(man3dir) + chmod 644 $(DESTDIR)$(man3dir)/zlib.3 + cp zlib.pc $(DESTDIR)$(pkgconfigdir) + chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc +# The ranlib in install is needed on NeXTSTEP which checks file times +# ldconfig is for Linux + +install: install-libs + -@if [ ! -d $(DESTDIR)$(includedir) ]; then mkdir -p $(DESTDIR)$(includedir); fi + cp zlib.h zconf.h $(DESTDIR)$(includedir) + chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h + +uninstall: + cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h + cd $(DESTDIR)$(libdir) && rm -f libz.a; \ + if test -n "$(SHAREDLIBV)" -a -f $(SHAREDLIBV); then \ + rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \ + fi + cd $(DESTDIR)$(man3dir) && rm -f zlib.3 + cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc + +docs: zlib.3.pdf + +zlib.3.pdf: zlib.3 + groff -mandoc -f H -T ps zlib.3 | ps2pdf - zlib.3.pdf + +zconf.h.cmakein: zconf.h.in + -@ TEMPFILE=zconfh_$$; \ + echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\ + sed -f $$TEMPFILE zconf.h.in > zconf.h.cmakein &&\ + touch -r zconf.h.in zconf.h.cmakein &&\ + rm $$TEMPFILE + +zconf: zconf.h.in + cp -p zconf.h.in zconf.h + +mostlyclean: clean +clean: + rm -f *.o *.lo *~ \ + example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \ + example64$(EXE) minigzip64$(EXE) \ + infcover \ + libz.* foo.gz so_locations \ + _match.s maketree contrib/infback9/*.o + rm -rf objs + rm -f *.gcda *.gcno *.gcov + rm -f contrib/infback9/*.gcda contrib/infback9/*.gcno contrib/infback9/*.gcov + +maintainer-clean: distclean +distclean: clean zconf zconf.h.cmakein docs + rm -f Makefile zlib.pc configure.log + -@rm -f .DS_Store + -@printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile + -@printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile + -@touch -r Makefile.in Makefile + +tags: + etags *.[ch] + +depend: + makedepend -- $(CFLAGS) -- *.[ch] + +# DO NOT DELETE THIS LINE -- make depend depends on it. + +adler32.o zutil.o: zutil.h zlib.h zconf.h +gzclose.o gzlib.o gzread.o gzwrite.o: zlib.h zconf.h gzguts.h +compress.o example.o minigzip.o uncompr.o: zlib.h zconf.h +crc32.o: zutil.h zlib.h zconf.h crc32.h +deflate.o: deflate.h zutil.h zlib.h zconf.h +infback.o inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h +inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h +inftrees.o: zutil.h zlib.h zconf.h inftrees.h +trees.o: deflate.h zutil.h zlib.h zconf.h trees.h + +adler32.lo zutil.lo: zutil.h zlib.h zconf.h +gzclose.lo gzlib.lo gzread.lo gzwrite.lo: zlib.h zconf.h gzguts.h +compress.lo example.lo minigzip.lo uncompr.lo: zlib.h zconf.h +crc32.lo: zutil.h zlib.h zconf.h crc32.h +deflate.lo: deflate.h zutil.h zlib.h zconf.h +infback.lo inflate.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h inffixed.h +inffast.lo: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h +inftrees.lo: zutil.h zlib.h zconf.h inftrees.h +trees.lo: deflate.h zutil.h zlib.h zconf.h trees.h diff --git a/zlib/src/README b/zlib/src/README new file mode 100644 index 0000000..5ca9d12 --- /dev/null +++ b/zlib/src/README @@ -0,0 +1,115 @@ +ZLIB DATA COMPRESSION LIBRARY + +zlib 1.2.8 is a general purpose data compression library. All the code is +thread safe. The data format used by the zlib library is described by RFCs +(Request for Comments) 1950 to 1952 in the files +http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and +rfc1952 (gzip format). + +All functions of the compression library are documented in the file zlib.h +(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example +of the library is given in the file test/example.c which also tests that +the library is working correctly. Another example is given in the file +test/minigzip.c. The compression library itself is composed of all source +files in the root directory. + +To compile all files and run the test program, follow the instructions given at +the top of Makefile.in. In short "./configure; make test", and if that goes +well, "make install" should work for most flavors of Unix. For Windows, use +one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use +make_vms.com. + +Questions about zlib should be sent to , or to Gilles Vollant + for the Windows DLL version. The zlib home page is +http://zlib.net/ . Before reporting a problem, please check this site to +verify that you have the latest version of zlib; otherwise get the latest +version and check whether the problem still exists or not. + +PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help. + +Mark Nelson wrote an article about zlib for the Jan. 1997 +issue of Dr. Dobb's Journal; a copy of the article is available at +http://marknelson.us/1997/01/01/zlib-engine/ . + +The changes made in version 1.2.8 are documented in the file ChangeLog. + +Unsupported third party contributions are provided in directory contrib/ . + +zlib is available in Java using the java.util.zip package, documented at +http://java.sun.com/developer/technicalArticles/Programming/compression/ . + +A Perl interface to zlib written by Paul Marquess is available +at CPAN (Comprehensive Perl Archive Network) sites, including +http://search.cpan.org/~pmqs/IO-Compress-Zlib/ . + +A Python interface to zlib written by A.M. Kuchling is +available in Python 1.5 and later versions, see +http://docs.python.org/library/zlib.html . + +zlib is built into tcl: http://wiki.tcl.tk/4610 . + +An experimental package to read and write files in .zip format, written on top +of zlib by Gilles Vollant , is available in the +contrib/minizip directory of zlib. + + +Notes for some targets: + +- For Windows DLL versions, please see win32/DLL_FAQ.txt + +- For 64-bit Irix, deflate.c must be compiled without any optimization. With + -O, one libpng test fails. The test works in 32 bit mode (with the -n32 + compiler flag). The compiler bug has been reported to SGI. + +- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works + when compiled with cc. + +- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is + necessary to get gzprintf working correctly. This is done by configure. + +- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with + other compilers. Use "make test" to check your compiler. + +- gzdopen is not supported on RISCOS or BEOS. + +- For PalmOs, see http://palmzlib.sourceforge.net/ + + +Acknowledgments: + + The deflate format used by zlib was defined by Phil Katz. The deflate and + zlib specifications were written by L. Peter Deutsch. Thanks to all the + people who reported problems and suggested various improvements in zlib; they + are too numerous to cite here. + +Copyright notice: + + (C) 1995-2013 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + +If you use the zlib library in a product, we would appreciate *not* receiving +lengthy legal documents to sign. The sources are provided for free but without +warranty of any kind. The library has been entirely written by Jean-loup +Gailly and Mark Adler; it does not include third-party code. + +If you redistribute modified sources, we would appreciate that you include in +the file ChangeLog history information documenting your changes. Please read +the FAQ for more information on the distribution of modified source versions. diff --git a/zlib/src/adler32.c b/zlib/src/adler32.c new file mode 100644 index 0000000..a868f07 --- /dev/null +++ b/zlib/src/adler32.c @@ -0,0 +1,179 @@ +/* adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-2011 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#include "zutil.h" + +#define local static + +local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); + +#define BASE 65521 /* largest prime smaller than 65536 */ +#define NMAX 5552 +/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ + +#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} +#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); +#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); +#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); +#define DO16(buf) DO8(buf,0); DO8(buf,8); + +/* use NO_DIVIDE if your processor does not do division in hardware -- + try it both ways to see which is faster */ +#ifdef NO_DIVIDE +/* note that this assumes BASE is 65521, where 65536 % 65521 == 15 + (thank you to John Reiser for pointing this out) */ +# define CHOP(a) \ + do { \ + unsigned long tmp = a >> 16; \ + a &= 0xffffUL; \ + a += (tmp << 4) - tmp; \ + } while (0) +# define MOD28(a) \ + do { \ + CHOP(a); \ + if (a >= BASE) a -= BASE; \ + } while (0) +# define MOD(a) \ + do { \ + CHOP(a); \ + MOD28(a); \ + } while (0) +# define MOD63(a) \ + do { /* this assumes a is not negative */ \ + z_off64_t tmp = a >> 32; \ + a &= 0xffffffffL; \ + a += (tmp << 8) - (tmp << 5) + tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + if (a >= BASE) a -= BASE; \ + } while (0) +#else +# define MOD(a) a %= BASE +# define MOD28(a) a %= BASE +# define MOD63(a) a %= BASE +#endif + +/* ========================================================================= */ +uLong ZEXPORT adler32(adler, buf, len) + uLong adler; + const Bytef *buf; + uInt len; +{ + unsigned long sum2; + unsigned n; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (len == 1) { + adler += buf[0]; + if (adler >= BASE) + adler -= BASE; + sum2 += adler; + if (sum2 >= BASE) + sum2 -= BASE; + return adler | (sum2 << 16); + } + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (buf == Z_NULL) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (len < 16) { + while (len--) { + adler += *buf++; + sum2 += adler; + } + if (adler >= BASE) + adler -= BASE; + MOD28(sum2); /* only added so many BASE's */ + return adler | (sum2 << 16); + } + + /* do length NMAX blocks -- requires just one modulo operation */ + while (len >= NMAX) { + len -= NMAX; + n = NMAX / 16; /* NMAX is divisible by 16 */ + do { + DO16(buf); /* 16 sums unrolled */ + buf += 16; + } while (--n); + MOD(adler); + MOD(sum2); + } + + /* do remaining bytes (less than NMAX, still just one modulo) */ + if (len) { /* avoid modulos if none remaining */ + while (len >= 16) { + len -= 16; + DO16(buf); + buf += 16; + } + while (len--) { + adler += *buf++; + sum2 += adler; + } + MOD(adler); + MOD(sum2); + } + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +/* ========================================================================= */ +local uLong adler32_combine_(adler1, adler2, len2) + uLong adler1; + uLong adler2; + z_off64_t len2; +{ + unsigned long sum1; + unsigned long sum2; + unsigned rem; + + /* for negative len, return invalid adler32 as a clue for debugging */ + if (len2 < 0) + return 0xffffffffUL; + + /* the derivation of this formula is left as an exercise for the reader */ + MOD63(len2); /* assumes len2 >= 0 */ + rem = (unsigned)len2; + sum1 = adler1 & 0xffff; + sum2 = rem * sum1; + MOD(sum2); + sum1 += (adler2 & 0xffff) + BASE - 1; + sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; + if (sum1 >= BASE) sum1 -= BASE; + if (sum1 >= BASE) sum1 -= BASE; + if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); + if (sum2 >= BASE) sum2 -= BASE; + return sum1 | (sum2 << 16); +} + +/* ========================================================================= */ +uLong ZEXPORT adler32_combine(adler1, adler2, len2) + uLong adler1; + uLong adler2; + z_off_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} + +uLong ZEXPORT adler32_combine64(adler1, adler2, len2) + uLong adler1; + uLong adler2; + z_off64_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} diff --git a/zlib/src/compress.c b/zlib/src/compress.c new file mode 100644 index 0000000..6e97626 --- /dev/null +++ b/zlib/src/compress.c @@ -0,0 +1,80 @@ +/* compress.c -- compress a memory buffer + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least 0.1% larger than sourceLen plus + 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ +int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; + int level; +{ + z_stream stream; + int err; + + stream.next_in = (z_const Bytef *)source; + stream.avail_in = (uInt)sourceLen; +#ifdef MAXSEG_64K + /* Check for source > 64K on 16-bit machine: */ + if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; +#endif + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + stream.opaque = (voidpf)0; + + err = deflateInit(&stream, level); + if (err != Z_OK) return err; + + err = deflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + deflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out; + + err = deflateEnd(&stream); + return err; +} + +/* =========================================================================== + */ +int ZEXPORT compress (dest, destLen, source, sourceLen) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; +{ + return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); +} + +/* =========================================================================== + If the default memLevel or windowBits for deflateInit() is changed, then + this function needs to be updated. + */ +uLong ZEXPORT compressBound (sourceLen) + uLong sourceLen; +{ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13; +} diff --git a/zlib/src/configure b/zlib/src/configure new file mode 100644 index 0000000..b77a8a8 --- /dev/null +++ b/zlib/src/configure @@ -0,0 +1,831 @@ +#!/bin/sh +# configure script for zlib. +# +# Normally configure builds both a static and a shared library. +# If you want to build just a static library, use: ./configure --static +# +# To impose specific compiler or flags or install directory, use for example: +# prefix=$HOME CC=cc CFLAGS="-O4" ./configure +# or for csh/tcsh users: +# (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure) + +# Incorrect settings of CC or CFLAGS may prevent creating a shared library. +# If you have problems, try without defining CC and CFLAGS before reporting +# an error. + +# start off configure.log +echo -------------------- >> configure.log +echo $0 $* >> configure.log +date >> configure.log + +# set command prefix for cross-compilation +if [ -n "${CHOST}" ]; then + uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`" + CROSS_PREFIX="${CHOST}-" +fi + +# destination name for static library +STATICLIB=libz.a + +# extract zlib version numbers from zlib.h +VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h` +VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < zlib.h` +VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < zlib.h` +VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < zlib.h` + +# establish commands for library building +if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then + AR=${AR-"${CROSS_PREFIX}ar"} + test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log +else + AR=${AR-"ar"} + test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log +fi +ARFLAGS=${ARFLAGS-"rc"} +if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then + RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"} + test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log +else + RANLIB=${RANLIB-"ranlib"} +fi +if "${CROSS_PREFIX}nm" --version >/dev/null 2>/dev/null || test $? -lt 126; then + NM=${NM-"${CROSS_PREFIX}nm"} + test -n "${CROSS_PREFIX}" && echo Using ${NM} | tee -a configure.log +else + NM=${NM-"nm"} +fi + +# set defaults before processing command line options +LDCONFIG=${LDCONFIG-"ldconfig"} +LDSHAREDLIBC="${LDSHAREDLIBC--lc}" +ARCHS= +prefix=${prefix-/usr/local} +exec_prefix=${exec_prefix-'${prefix}'} +libdir=${libdir-'${exec_prefix}/lib'} +sharedlibdir=${sharedlibdir-'${libdir}'} +includedir=${includedir-'${prefix}/include'} +mandir=${mandir-'${prefix}/share/man'} +shared_ext='.so' +shared=1 +solo=0 +cover=0 +zprefix=0 +zconst=0 +build64=0 +gcc=0 +old_cc="$CC" +old_cflags="$CFLAGS" +OBJC='$(OBJZ) $(OBJG)' +PIC_OBJC='$(PIC_OBJZ) $(PIC_OBJG)' + +# leave this script, optionally in a bad way +leave() +{ + if test "$*" != "0"; then + echo "** $0 aborting." | tee -a configure.log + fi + rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version + echo -------------------- >> configure.log + echo >> configure.log + echo >> configure.log + exit $1 +} + +# process command line options +while test $# -ge 1 +do +case "$1" in + -h* | --help) + echo 'usage:' | tee -a configure.log + echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log + echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log + echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log + exit 0 ;; + -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;; + -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;; + -l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;; + --sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;; + -i*=* | --includedir=*) includedir=`echo $1 | sed 's/.*=//'`;shift ;; + -u*=* | --uname=*) uname=`echo $1 | sed 's/.*=//'`;shift ;; + -p* | --prefix) prefix="$2"; shift; shift ;; + -e* | --eprefix) exec_prefix="$2"; shift; shift ;; + -l* | --libdir) libdir="$2"; shift; shift ;; + -i* | --includedir) includedir="$2"; shift; shift ;; + -s* | --shared | --enable-shared) shared=1; shift ;; + -t | --static) shared=0; shift ;; + --solo) solo=1; shift ;; + --cover) cover=1; shift ;; + -z* | --zprefix) zprefix=1; shift ;; + -6* | --64) build64=1; shift ;; + -a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;; + --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;; + --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;; + -c* | --const) zconst=1; shift ;; + *) + echo "unknown option: $1" | tee -a configure.log + echo "$0 --help for help" | tee -a configure.log + leave 1;; + esac +done + +# temporary file name +test=ztest$$ + +# put arguments in log, also put test file in log if used in arguments +show() +{ + case "$*" in + *$test.c*) + echo === $test.c === >> configure.log + cat $test.c >> configure.log + echo === >> configure.log;; + esac + echo $* >> configure.log +} + +# check for gcc vs. cc and set compile and link flags based on the system identified by uname +cat > $test.c <&1` in + *gcc*) gcc=1 ;; +esac + +show $cc -c $test.c +if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then + echo ... using gcc >> configure.log + CC="$cc" + CFLAGS="${CFLAGS--O3} ${ARCHS}" + SFLAGS="${CFLAGS--O3} -fPIC" + LDFLAGS="${LDFLAGS} ${ARCHS}" + if test $build64 -eq 1; then + CFLAGS="${CFLAGS} -m64" + SFLAGS="${SFLAGS} -m64" + fi + if test "${ZLIBGCCWARN}" = "YES"; then + if test "$zconst" -eq 1; then + CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST" + else + CFLAGS="${CFLAGS} -Wall -Wextra -pedantic" + fi + fi + if test -z "$uname"; then + uname=`(uname -s || echo unknown) 2>/dev/null` + fi + case "$uname" in + Linux* | linux* | GNU | GNU/* | solaris*) + LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"} ;; + *BSD | *bsd* | DragonFly) + LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,zlib.map"} + LDCONFIG="ldconfig -m" ;; + CYGWIN* | Cygwin* | cygwin* | OS/2*) + EXE='.exe' ;; + MINGW* | mingw*) +# temporary bypass + rm -f $test.[co] $test $test$shared_ext + echo "Please use win32/Makefile.gcc instead." | tee -a configure.log + leave 1 + LDSHARED=${LDSHARED-"$cc -shared"} + LDSHAREDLIBC="" + EXE='.exe' ;; + QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4 + # (alain.bonnefoy@icbt.com) + LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;; + HP-UX*) + LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"} + case `(uname -m || echo unknown) 2>/dev/null` in + ia64) + shared_ext='.so' + SHAREDLIB='libz.so' ;; + *) + shared_ext='.sl' + SHAREDLIB='libz.sl' ;; + esac ;; + Darwin* | darwin*) + shared_ext='.dylib' + SHAREDLIB=libz$shared_ext + SHAREDLIBV=libz.$VER$shared_ext + SHAREDLIBM=libz.$VER1$shared_ext + LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"} + if libtool -V 2>&1 | grep Apple > /dev/null; then + AR="libtool" + else + AR="/usr/bin/libtool" + fi + ARFLAGS="-o" ;; + *) LDSHARED=${LDSHARED-"$cc -shared"} ;; + esac +else + # find system name and corresponding cc options + CC=${CC-cc} + gcc=0 + echo ... using $CC >> configure.log + if test -z "$uname"; then + uname=`(uname -sr || echo unknown) 2>/dev/null` + fi + case "$uname" in + HP-UX*) SFLAGS=${CFLAGS-"-O +z"} + CFLAGS=${CFLAGS-"-O"} +# LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"} + LDSHARED=${LDSHARED-"ld -b"} + case `(uname -m || echo unknown) 2>/dev/null` in + ia64) + shared_ext='.so' + SHAREDLIB='libz.so' ;; + *) + shared_ext='.sl' + SHAREDLIB='libz.sl' ;; + esac ;; + IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."} + CFLAGS=${CFLAGS-"-ansi -O2"} + LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;; + OSF1\ V4*) SFLAGS=${CFLAGS-"-O -std1"} + CFLAGS=${CFLAGS-"-O -std1"} + LDFLAGS="${LDFLAGS} -Wl,-rpath,." + LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so -Wl,-msym -Wl,-rpath,$(libdir) -Wl,-set_version,${VER}:1.0"} ;; + OSF1*) SFLAGS=${CFLAGS-"-O -std1"} + CFLAGS=${CFLAGS-"-O -std1"} + LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;; + QNX*) SFLAGS=${CFLAGS-"-4 -O"} + CFLAGS=${CFLAGS-"-4 -O"} + LDSHARED=${LDSHARED-"cc"} + RANLIB=${RANLIB-"true"} + AR="cc" + ARFLAGS="-A" ;; + SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "} + CFLAGS=${CFLAGS-"-O3"} + LDSHARED=${LDSHARED-"cc -dy -KPIC -G"} ;; + SunOS\ 5* | solaris*) + LDSHARED=${LDSHARED-"cc -G -h libz$shared_ext.$VER1"} + SFLAGS=${CFLAGS-"-fast -KPIC"} + CFLAGS=${CFLAGS-"-fast"} + if test $build64 -eq 1; then + # old versions of SunPRO/Workshop/Studio don't support -m64, + # but newer ones do. Check for it. + flag64=`$CC -flags | egrep -- '^-m64'` + if test x"$flag64" != x"" ; then + CFLAGS="${CFLAGS} -m64" + SFLAGS="${SFLAGS} -m64" + else + case `(uname -m || echo unknown) 2>/dev/null` in + i86*) + SFLAGS="$SFLAGS -xarch=amd64" + CFLAGS="$CFLAGS -xarch=amd64" ;; + *) + SFLAGS="$SFLAGS -xarch=v9" + CFLAGS="$CFLAGS -xarch=v9" ;; + esac + fi + fi + ;; + SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"} + CFLAGS=${CFLAGS-"-O2"} + LDSHARED=${LDSHARED-"ld"} ;; + SunStudio\ 9*) SFLAGS=${CFLAGS-"-fast -xcode=pic32 -xtarget=ultra3 -xarch=v9b"} + CFLAGS=${CFLAGS-"-fast -xtarget=ultra3 -xarch=v9b"} + LDSHARED=${LDSHARED-"cc -xarch=v9b"} ;; + UNIX_System_V\ 4.2.0) + SFLAGS=${CFLAGS-"-KPIC -O"} + CFLAGS=${CFLAGS-"-O"} + LDSHARED=${LDSHARED-"cc -G"} ;; + UNIX_SV\ 4.2MP) + SFLAGS=${CFLAGS-"-Kconform_pic -O"} + CFLAGS=${CFLAGS-"-O"} + LDSHARED=${LDSHARED-"cc -G"} ;; + OpenUNIX\ 5) + SFLAGS=${CFLAGS-"-KPIC -O"} + CFLAGS=${CFLAGS-"-O"} + LDSHARED=${LDSHARED-"cc -G"} ;; + AIX*) # Courtesy of dbakker@arrayasolutions.com + SFLAGS=${CFLAGS-"-O -qmaxmem=8192"} + CFLAGS=${CFLAGS-"-O -qmaxmem=8192"} + LDSHARED=${LDSHARED-"xlc -G"} ;; + # send working options for other systems to zlib@gzip.org + *) SFLAGS=${CFLAGS-"-O"} + CFLAGS=${CFLAGS-"-O"} + LDSHARED=${LDSHARED-"cc -shared"} ;; + esac +fi + +# destination names for shared library if not defined above +SHAREDLIB=${SHAREDLIB-"libz$shared_ext"} +SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"} +SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"} + +echo >> configure.log + +# define functions for testing compiler and library characteristics and logging the results + +cat > $test.c </dev/null; then + try() + { + show $* + test "`( $* ) 2>&1 | tee -a configure.log`" = "" + } + echo - using any output from compiler to indicate an error >> configure.log +else +try() +{ + show $* + ( $* ) >> configure.log 2>&1 + ret=$? + if test $ret -ne 0; then + echo "(exit code "$ret")" >> configure.log + fi + return $ret +} +fi + +tryboth() +{ + show $* + got=`( $* ) 2>&1` + ret=$? + printf %s "$got" >> configure.log + if test $ret -ne 0; then + return $ret + fi + test "$got" = "" +} + +cat > $test.c << EOF +int foo() { return 0; } +EOF +echo "Checking for obsessive-compulsive compiler options..." >> configure.log +if try $CC -c $CFLAGS $test.c; then + : +else + echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log + leave 1 +fi + +echo >> configure.log + +# see if shared library build supported +cat > $test.c <> configure.log + show "$NM $test.o | grep _hello" + if test "`$NM $test.o | grep _hello | tee -a configure.log`" = ""; then + CPP="$CPP -DNO_UNDERLINE" + echo Checking for underline in external names... No. | tee -a configure.log + else + echo Checking for underline in external names... Yes. | tee -a configure.log + fi ;; +esac + +echo >> configure.log + +# check for large file support, and if none, check for fseeko() +cat > $test.c < +off64_t dummy = 0; +EOF +if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then + CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1" + SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1" + ALL="${ALL} all64" + TEST="${TEST} test64" + echo "Checking for off64_t... Yes." | tee -a configure.log + echo "Checking for fseeko... Yes." | tee -a configure.log +else + echo "Checking for off64_t... No." | tee -a configure.log + echo >> configure.log + cat > $test.c < +int main(void) { + fseeko(NULL, 0, 0); + return 0; +} +EOF + if try $CC $CFLAGS -o $test $test.c; then + echo "Checking for fseeko... Yes." | tee -a configure.log + else + CFLAGS="${CFLAGS} -DNO_FSEEKO" + SFLAGS="${SFLAGS} -DNO_FSEEKO" + echo "Checking for fseeko... No." | tee -a configure.log + fi +fi + +echo >> configure.log + +# check for strerror() for use by gz* functions +cat > $test.c < +#include +int main() { return strlen(strerror(errno)); } +EOF +if try $CC $CFLAGS -o $test $test.c; then + echo "Checking for strerror... Yes." | tee -a configure.log +else + CFLAGS="${CFLAGS} -DNO_STRERROR" + SFLAGS="${SFLAGS} -DNO_STRERROR" + echo "Checking for strerror... No." | tee -a configure.log +fi + +# copy clean zconf.h for subsequent edits +cp -p zconf.h.in zconf.h + +echo >> configure.log + +# check for unistd.h and save result in zconf.h +cat > $test.c < +int main() { return 0; } +EOF +if try $CC -c $CFLAGS $test.c; then + sed < zconf.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf.temp.h + mv zconf.temp.h zconf.h + echo "Checking for unistd.h... Yes." | tee -a configure.log +else + echo "Checking for unistd.h... No." | tee -a configure.log +fi + +echo >> configure.log + +# check for stdarg.h and save result in zconf.h +cat > $test.c < +int main() { return 0; } +EOF +if try $CC -c $CFLAGS $test.c; then + sed < zconf.h "/^#ifdef HAVE_STDARG_H.* may be/s/def HAVE_STDARG_H\(.*\) may be/ 1\1 was/" > zconf.temp.h + mv zconf.temp.h zconf.h + echo "Checking for stdarg.h... Yes." | tee -a configure.log +else + echo "Checking for stdarg.h... No." | tee -a configure.log +fi + +# if the z_ prefix was requested, save that in zconf.h +if test $zprefix -eq 1; then + sed < zconf.h "/#ifdef Z_PREFIX.* may be/s/def Z_PREFIX\(.*\) may be/ 1\1 was/" > zconf.temp.h + mv zconf.temp.h zconf.h + echo >> configure.log + echo "Using z_ prefix on all symbols." | tee -a configure.log +fi + +# if --solo compilation was requested, save that in zconf.h and remove gz stuff from object lists +if test $solo -eq 1; then + sed '/#define ZCONF_H/a\ +#define Z_SOLO + +' < zconf.h > zconf.temp.h + mv zconf.temp.h zconf.h +OBJC='$(OBJZ)' +PIC_OBJC='$(PIC_OBJZ)' +fi + +# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X +if test $cover -eq 1; then + CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage" + if test -n "$GCC_CLASSIC"; then + CC=$GCC_CLASSIC + fi +fi + +echo >> configure.log + +# conduct a series of tests to resolve eight possible cases of using "vs" or "s" printf functions +# (using stdarg or not), with or without "n" (proving size of buffer), and with or without a +# return value. The most secure result is vsnprintf() with a return value. snprintf() with a +# return value is secure as well, but then gzprintf() will be limited to 20 arguments. +cat > $test.c < +#include +#include "zconf.h" +int main() +{ +#ifndef STDC + choke me +#endif + return 0; +} +EOF +if try $CC -c $CFLAGS $test.c; then + echo "Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf()." | tee -a configure.log + + echo >> configure.log + cat > $test.c < +#include +int mytest(const char *fmt, ...) +{ + char buf[20]; + va_list ap; + va_start(ap, fmt); + vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return 0; +} +int main() +{ + return (mytest("Hello%d\n", 1)); +} +EOF + if try $CC $CFLAGS -o $test $test.c; then + echo "Checking for vsnprintf() in stdio.h... Yes." | tee -a configure.log + + echo >> configure.log + cat >$test.c < +#include +int mytest(const char *fmt, ...) +{ + int n; + char buf[20]; + va_list ap; + va_start(ap, fmt); + n = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return n; +} +int main() +{ + return (mytest("Hello%d\n", 1)); +} +EOF + + if try $CC -c $CFLAGS $test.c; then + echo "Checking for return value of vsnprintf()... Yes." | tee -a configure.log + else + CFLAGS="$CFLAGS -DHAS_vsnprintf_void" + SFLAGS="$SFLAGS -DHAS_vsnprintf_void" + echo "Checking for return value of vsnprintf()... No." | tee -a configure.log + echo " WARNING: apparently vsnprintf() does not return a value. zlib" | tee -a configure.log + echo " can build but will be open to possible string-format security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + fi + else + CFLAGS="$CFLAGS -DNO_vsnprintf" + SFLAGS="$SFLAGS -DNO_vsnprintf" + echo "Checking for vsnprintf() in stdio.h... No." | tee -a configure.log + echo " WARNING: vsnprintf() not found, falling back to vsprintf(). zlib" | tee -a configure.log + echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + + echo >> configure.log + cat >$test.c < +#include +int mytest(const char *fmt, ...) +{ + int n; + char buf[20]; + va_list ap; + va_start(ap, fmt); + n = vsprintf(buf, fmt, ap); + va_end(ap); + return n; +} +int main() +{ + return (mytest("Hello%d\n", 1)); +} +EOF + + if try $CC -c $CFLAGS $test.c; then + echo "Checking for return value of vsprintf()... Yes." | tee -a configure.log + else + CFLAGS="$CFLAGS -DHAS_vsprintf_void" + SFLAGS="$SFLAGS -DHAS_vsprintf_void" + echo "Checking for return value of vsprintf()... No." | tee -a configure.log + echo " WARNING: apparently vsprintf() does not return a value. zlib" | tee -a configure.log + echo " can build but will be open to possible string-format security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + fi + fi +else + echo "Checking whether to use vs[n]printf() or s[n]printf()... using s[n]printf()." | tee -a configure.log + + echo >> configure.log + cat >$test.c < +int mytest() +{ + char buf[20]; + snprintf(buf, sizeof(buf), "%s", "foo"); + return 0; +} +int main() +{ + return (mytest()); +} +EOF + + if try $CC $CFLAGS -o $test $test.c; then + echo "Checking for snprintf() in stdio.h... Yes." | tee -a configure.log + + echo >> configure.log + cat >$test.c < +int mytest() +{ + char buf[20]; + return snprintf(buf, sizeof(buf), "%s", "foo"); +} +int main() +{ + return (mytest()); +} +EOF + + if try $CC -c $CFLAGS $test.c; then + echo "Checking for return value of snprintf()... Yes." | tee -a configure.log + else + CFLAGS="$CFLAGS -DHAS_snprintf_void" + SFLAGS="$SFLAGS -DHAS_snprintf_void" + echo "Checking for return value of snprintf()... No." | tee -a configure.log + echo " WARNING: apparently snprintf() does not return a value. zlib" | tee -a configure.log + echo " can build but will be open to possible string-format security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + fi + else + CFLAGS="$CFLAGS -DNO_snprintf" + SFLAGS="$SFLAGS -DNO_snprintf" + echo "Checking for snprintf() in stdio.h... No." | tee -a configure.log + echo " WARNING: snprintf() not found, falling back to sprintf(). zlib" | tee -a configure.log + echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + + echo >> configure.log + cat >$test.c < +int mytest() +{ + char buf[20]; + return sprintf(buf, "%s", "foo"); +} +int main() +{ + return (mytest()); +} +EOF + + if try $CC -c $CFLAGS $test.c; then + echo "Checking for return value of sprintf()... Yes." | tee -a configure.log + else + CFLAGS="$CFLAGS -DHAS_sprintf_void" + SFLAGS="$SFLAGS -DHAS_sprintf_void" + echo "Checking for return value of sprintf()... No." | tee -a configure.log + echo " WARNING: apparently sprintf() does not return a value. zlib" | tee -a configure.log + echo " can build but will be open to possible string-format security" | tee -a configure.log + echo " vulnerabilities." | tee -a configure.log + fi + fi +fi + +# see if we can hide zlib internal symbols that are linked between separate source files +if test "$gcc" -eq 1; then + echo >> configure.log + cat > $test.c <> configure.log +echo ALL = $ALL >> configure.log +echo AR = $AR >> configure.log +echo ARFLAGS = $ARFLAGS >> configure.log +echo CC = $CC >> configure.log +echo CFLAGS = $CFLAGS >> configure.log +echo CPP = $CPP >> configure.log +echo EXE = $EXE >> configure.log +echo LDCONFIG = $LDCONFIG >> configure.log +echo LDFLAGS = $LDFLAGS >> configure.log +echo LDSHARED = $LDSHARED >> configure.log +echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log +echo OBJC = $OBJC >> configure.log +echo PIC_OBJC = $PIC_OBJC >> configure.log +echo RANLIB = $RANLIB >> configure.log +echo SFLAGS = $SFLAGS >> configure.log +echo SHAREDLIB = $SHAREDLIB >> configure.log +echo SHAREDLIBM = $SHAREDLIBM >> configure.log +echo SHAREDLIBV = $SHAREDLIBV >> configure.log +echo STATICLIB = $STATICLIB >> configure.log +echo TEST = $TEST >> configure.log +echo VER = $VER >> configure.log +echo Z_U4 = $Z_U4 >> configure.log +echo exec_prefix = $exec_prefix >> configure.log +echo includedir = $includedir >> configure.log +echo libdir = $libdir >> configure.log +echo mandir = $mandir >> configure.log +echo prefix = $prefix >> configure.log +echo sharedlibdir = $sharedlibdir >> configure.log +echo uname = $uname >> configure.log + +# udpate Makefile with the configure results +sed < Makefile.in " +/^CC *=/s#=.*#=$CC# +/^CFLAGS *=/s#=.*#=$CFLAGS# +/^SFLAGS *=/s#=.*#=$SFLAGS# +/^LDFLAGS *=/s#=.*#=$LDFLAGS# +/^LDSHARED *=/s#=.*#=$LDSHARED# +/^CPP *=/s#=.*#=$CPP# +/^STATICLIB *=/s#=.*#=$STATICLIB# +/^SHAREDLIB *=/s#=.*#=$SHAREDLIB# +/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV# +/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM# +/^AR *=/s#=.*#=$AR# +/^ARFLAGS *=/s#=.*#=$ARFLAGS# +/^RANLIB *=/s#=.*#=$RANLIB# +/^LDCONFIG *=/s#=.*#=$LDCONFIG# +/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC# +/^EXE *=/s#=.*#=$EXE# +/^prefix *=/s#=.*#=$prefix# +/^exec_prefix *=/s#=.*#=$exec_prefix# +/^libdir *=/s#=.*#=$libdir# +/^sharedlibdir *=/s#=.*#=$sharedlibdir# +/^includedir *=/s#=.*#=$includedir# +/^mandir *=/s#=.*#=$mandir# +/^OBJC *=/s#=.*#= $OBJC# +/^PIC_OBJC *=/s#=.*#= $PIC_OBJC# +/^all: */s#:.*#: $ALL# +/^test: */s#:.*#: $TEST# +" > Makefile + +# create zlib.pc with the configure results +sed < zlib.pc.in " +/^CC *=/s#=.*#=$CC# +/^CFLAGS *=/s#=.*#=$CFLAGS# +/^CPP *=/s#=.*#=$CPP# +/^LDSHARED *=/s#=.*#=$LDSHARED# +/^STATICLIB *=/s#=.*#=$STATICLIB# +/^SHAREDLIB *=/s#=.*#=$SHAREDLIB# +/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV# +/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM# +/^AR *=/s#=.*#=$AR# +/^ARFLAGS *=/s#=.*#=$ARFLAGS# +/^RANLIB *=/s#=.*#=$RANLIB# +/^EXE *=/s#=.*#=$EXE# +/^prefix *=/s#=.*#=$prefix# +/^exec_prefix *=/s#=.*#=$exec_prefix# +/^libdir *=/s#=.*#=$libdir# +/^sharedlibdir *=/s#=.*#=$sharedlibdir# +/^includedir *=/s#=.*#=$includedir# +/^mandir *=/s#=.*#=$mandir# +/^LDFLAGS *=/s#=.*#=$LDFLAGS# +" | sed -e " +s/\@VERSION\@/$VER/g; +" > zlib.pc + +# done +leave 0 diff --git a/zlib/src/crc32.c b/zlib/src/crc32.c new file mode 100644 index 0000000..979a719 --- /dev/null +++ b/zlib/src/crc32.c @@ -0,0 +1,425 @@ +/* crc32.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Thanks to Rodney Brown for his contribution of faster + * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing + * tables for updating the shift register in one step with three exclusive-ors + * instead of four steps with four exclusive-ors. This results in about a + * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. + */ + +/* @(#) $Id$ */ + +/* + Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore + protection on the static variables used to control the first-use generation + of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should + first call get_crc_table() to initialize the tables before allowing more than + one thread to use crc32(). + + DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. + */ + +#ifdef MAKECRCH +# include +# ifndef DYNAMIC_CRC_TABLE +# define DYNAMIC_CRC_TABLE +# endif /* !DYNAMIC_CRC_TABLE */ +#endif /* MAKECRCH */ + +#include "zutil.h" /* for STDC and FAR definitions */ + +#define local static + +/* Definitions for doing the crc four data bytes at a time. */ +#if !defined(NOBYFOUR) && defined(Z_U4) +# define BYFOUR +#endif +#ifdef BYFOUR + local unsigned long crc32_little OF((unsigned long, + const unsigned char FAR *, unsigned)); + local unsigned long crc32_big OF((unsigned long, + const unsigned char FAR *, unsigned)); +# define TBLS 8 +#else +# define TBLS 1 +#endif /* BYFOUR */ + +/* Local functions for crc concatenation */ +local unsigned long gf2_matrix_times OF((unsigned long *mat, + unsigned long vec)); +local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); +local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); + + +#ifdef DYNAMIC_CRC_TABLE + +local volatile int crc_table_empty = 1; +local z_crc_t FAR crc_table[TBLS][256]; +local void make_crc_table OF((void)); +#ifdef MAKECRCH + local void write_table OF((FILE *, const z_crc_t FAR *)); +#endif /* MAKECRCH */ +/* + Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The first table is simply the CRC of all possible eight bit values. This is + all the information needed to generate CRCs on data a byte at a time for all + combinations of CRC register values and incoming bytes. The remaining tables + allow for word-at-a-time CRC calculation for both big-endian and little- + endian machines, where a word is four bytes. +*/ +local void make_crc_table() +{ + z_crc_t c; + int n, k; + z_crc_t poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static volatile int first = 1; /* flag to limit concurrent making */ + static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* See if another task is already doing this (not thread-safe, but better + than nothing -- significantly reduces duration of vulnerability in + case the advice about DYNAMIC_CRC_TABLE is ignored) */ + if (first) { + first = 0; + + /* make exclusive-or pattern from polynomial (0xedb88320UL) */ + poly = 0; + for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) + poly |= (z_crc_t)1 << (31 - p[n]); + + /* generate a crc for every 8-bit value */ + for (n = 0; n < 256; n++) { + c = (z_crc_t)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; + } + +#ifdef BYFOUR + /* generate crc for each value followed by one, two, and three zeros, + and then the byte reversal of those as well as the first table */ + for (n = 0; n < 256; n++) { + c = crc_table[0][n]; + crc_table[4][n] = ZSWAP32(c); + for (k = 1; k < 4; k++) { + c = crc_table[0][c & 0xff] ^ (c >> 8); + crc_table[k][n] = c; + crc_table[k + 4][n] = ZSWAP32(c); + } + } +#endif /* BYFOUR */ + + crc_table_empty = 0; + } + else { /* not first */ + /* wait for the other guy to finish (not efficient, but rare) */ + while (crc_table_empty) + ; + } + +#ifdef MAKECRCH + /* write out CRC tables to crc32.h */ + { + FILE *out; + + out = fopen("crc32.h", "w"); + if (out == NULL) return; + fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); + fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); + fprintf(out, "local const z_crc_t FAR "); + fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); + write_table(out, crc_table[0]); +# ifdef BYFOUR + fprintf(out, "#ifdef BYFOUR\n"); + for (k = 1; k < 8; k++) { + fprintf(out, " },\n {\n"); + write_table(out, crc_table[k]); + } + fprintf(out, "#endif\n"); +# endif /* BYFOUR */ + fprintf(out, " }\n};\n"); + fclose(out); + } +#endif /* MAKECRCH */ +} + +#ifdef MAKECRCH +local void write_table(out, table) + FILE *out; + const z_crc_t FAR *table; +{ + int n; + + for (n = 0; n < 256; n++) + fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", + (unsigned long)(table[n]), + n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); +} +#endif /* MAKECRCH */ + +#else /* !DYNAMIC_CRC_TABLE */ +/* ======================================================================== + * Tables of CRC-32s of all single-byte values, made by make_crc_table(). + */ +#include "crc32.h" +#endif /* DYNAMIC_CRC_TABLE */ + +/* ========================================================================= + * This function can be used by asm versions of crc32() + */ +const z_crc_t FAR * ZEXPORT get_crc_table() +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + return (const z_crc_t FAR *)crc_table; +} + +/* ========================================================================= */ +#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) +#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 + +/* ========================================================================= */ +unsigned long ZEXPORT crc32(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; + uInt len; +{ + if (buf == Z_NULL) return 0UL; + +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + +#ifdef BYFOUR + if (sizeof(void *) == sizeof(ptrdiff_t)) { + z_crc_t endian; + + endian = 1; + if (*((unsigned char *)(&endian))) + return crc32_little(crc, buf, len); + else + return crc32_big(crc, buf, len); + } +#endif /* BYFOUR */ + crc = crc ^ 0xffffffffUL; + while (len >= 8) { + DO8; + len -= 8; + } + if (len) do { + DO1; + } while (--len); + return crc ^ 0xffffffffUL; +} + +#ifdef BYFOUR + +/* ========================================================================= */ +#define DOLIT4 c ^= *buf4++; \ + c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ + crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] +#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 + +/* ========================================================================= */ +local unsigned long crc32_little(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = (z_crc_t)crc; + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + while (len >= 32) { + DOLIT32; + len -= 32; + } + while (len >= 4) { + DOLIT4; + len -= 4; + } + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + } while (--len); + c = ~c; + return (unsigned long)c; +} + +/* ========================================================================= */ +#define DOBIG4 c ^= *++buf4; \ + c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ + crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] +#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 + +/* ========================================================================= */ +local unsigned long crc32_big(crc, buf, len) + unsigned long crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = ZSWAP32((z_crc_t)crc); + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + buf4--; + while (len >= 32) { + DOBIG32; + len -= 32; + } + while (len >= 4) { + DOBIG4; + len -= 4; + } + buf4++; + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + } while (--len); + c = ~c; + return (unsigned long)(ZSWAP32(c)); +} + +#endif /* BYFOUR */ + +#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ + +/* ========================================================================= */ +local unsigned long gf2_matrix_times(mat, vec) + unsigned long *mat; + unsigned long vec; +{ + unsigned long sum; + + sum = 0; + while (vec) { + if (vec & 1) + sum ^= *mat; + vec >>= 1; + mat++; + } + return sum; +} + +/* ========================================================================= */ +local void gf2_matrix_square(square, mat) + unsigned long *square; + unsigned long *mat; +{ + int n; + + for (n = 0; n < GF2_DIM; n++) + square[n] = gf2_matrix_times(mat, mat[n]); +} + +/* ========================================================================= */ +local uLong crc32_combine_(crc1, crc2, len2) + uLong crc1; + uLong crc2; + z_off64_t len2; +{ + int n; + unsigned long row; + unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */ + unsigned long odd[GF2_DIM]; /* odd-power-of-two zeros operator */ + + /* degenerate case (also disallow negative lengths) */ + if (len2 <= 0) + return crc1; + + /* put operator for one zero bit in odd */ + odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ + row = 1; + for (n = 1; n < GF2_DIM; n++) { + odd[n] = row; + row <<= 1; + } + + /* put operator for two zero bits in even */ + gf2_matrix_square(even, odd); + + /* put operator for four zero bits in odd */ + gf2_matrix_square(odd, even); + + /* apply len2 zeros to crc1 (first square will put the operator for one + zero byte, eight zero bits, in even) */ + do { + /* apply zeros operator for this bit of len2 */ + gf2_matrix_square(even, odd); + if (len2 & 1) + crc1 = gf2_matrix_times(even, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + if (len2 == 0) + break; + + /* another iteration of the loop with odd and even swapped */ + gf2_matrix_square(odd, even); + if (len2 & 1) + crc1 = gf2_matrix_times(odd, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + } while (len2 != 0); + + /* return combined crc */ + crc1 ^= crc2; + return crc1; +} + +/* ========================================================================= */ +uLong ZEXPORT crc32_combine(crc1, crc2, len2) + uLong crc1; + uLong crc2; + z_off_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} + +uLong ZEXPORT crc32_combine64(crc1, crc2, len2) + uLong crc1; + uLong crc2; + z_off64_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} diff --git a/zlib/src/crc32.h b/zlib/src/crc32.h new file mode 100644 index 0000000..9e0c778 --- /dev/null +++ b/zlib/src/crc32.h @@ -0,0 +1,441 @@ +/* crc32.h -- tables for rapid CRC calculation + * Generated automatically by crc32.c + */ + +local const z_crc_t FAR crc_table[TBLS][256] = +{ + { + 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, + 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, + 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, + 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, + 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, + 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, + 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, + 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, + 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, + 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, + 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, + 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, + 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, + 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, + 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, + 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, + 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, + 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, + 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, + 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, + 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, + 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, + 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, + 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, + 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, + 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, + 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, + 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, + 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, + 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, + 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, + 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, + 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, + 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, + 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, + 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, + 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, + 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, + 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, + 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, + 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, + 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, + 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, + 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, + 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, + 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, + 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, + 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, + 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, + 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, + 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, + 0x2d02ef8dUL +#ifdef BYFOUR + }, + { + 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, + 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, + 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, + 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, + 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, + 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, + 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, + 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, + 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, + 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, + 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, + 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, + 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, + 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, + 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, + 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, + 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, + 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, + 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, + 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, + 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, + 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, + 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, + 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, + 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, + 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, + 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, + 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, + 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, + 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, + 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, + 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, + 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, + 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, + 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, + 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, + 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, + 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, + 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, + 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, + 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, + 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, + 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, + 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, + 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, + 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, + 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, + 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, + 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, + 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, + 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, + 0x9324fd72UL + }, + { + 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, + 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, + 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, + 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, + 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, + 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, + 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, + 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, + 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, + 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, + 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, + 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, + 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, + 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, + 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, + 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, + 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, + 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, + 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, + 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, + 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, + 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, + 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, + 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, + 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, + 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, + 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, + 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, + 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, + 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, + 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, + 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, + 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, + 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, + 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, + 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, + 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, + 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, + 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, + 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, + 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, + 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, + 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, + 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, + 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, + 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, + 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, + 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, + 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, + 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, + 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, + 0xbe9834edUL + }, + { + 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, + 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, + 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, + 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, + 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, + 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, + 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, + 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, + 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, + 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, + 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, + 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, + 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, + 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, + 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, + 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, + 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, + 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, + 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, + 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, + 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, + 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, + 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, + 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, + 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, + 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, + 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, + 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, + 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, + 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, + 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, + 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, + 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, + 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, + 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, + 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, + 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, + 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, + 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, + 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, + 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, + 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, + 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, + 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, + 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, + 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, + 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, + 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, + 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, + 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, + 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, + 0xde0506f1UL + }, + { + 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, + 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, + 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, + 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, + 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, + 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, + 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, + 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, + 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, + 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, + 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, + 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, + 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, + 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, + 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, + 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, + 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, + 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, + 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, + 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, + 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, + 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, + 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, + 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, + 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, + 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, + 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, + 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, + 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, + 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, + 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, + 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, + 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, + 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, + 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, + 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, + 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, + 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, + 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, + 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, + 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, + 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, + 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, + 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, + 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, + 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, + 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, + 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, + 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, + 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, + 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, + 0x8def022dUL + }, + { + 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, + 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, + 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, + 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, + 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, + 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, + 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, + 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, + 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, + 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, + 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, + 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, + 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, + 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, + 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, + 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, + 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, + 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, + 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, + 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, + 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, + 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, + 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, + 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, + 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, + 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, + 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, + 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, + 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, + 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, + 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, + 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, + 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, + 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, + 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, + 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, + 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, + 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, + 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, + 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, + 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, + 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, + 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, + 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, + 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, + 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, + 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, + 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, + 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, + 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, + 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, + 0x72fd2493UL + }, + { + 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, + 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, + 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, + 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, + 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, + 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, + 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, + 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, + 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, + 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, + 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, + 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, + 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, + 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, + 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, + 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, + 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, + 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, + 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, + 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, + 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, + 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, + 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, + 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, + 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, + 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, + 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, + 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, + 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, + 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, + 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, + 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, + 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, + 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, + 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, + 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, + 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, + 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, + 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, + 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, + 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, + 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, + 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, + 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, + 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, + 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, + 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, + 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, + 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, + 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, + 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, + 0xed3498beUL + }, + { + 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, + 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, + 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, + 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, + 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, + 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, + 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, + 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, + 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, + 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, + 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, + 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, + 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, + 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, + 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, + 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, + 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, + 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, + 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, + 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, + 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, + 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, + 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, + 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, + 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, + 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, + 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, + 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, + 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, + 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, + 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, + 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, + 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, + 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, + 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, + 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, + 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, + 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, + 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, + 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, + 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, + 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, + 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, + 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, + 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, + 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, + 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, + 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, + 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, + 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, + 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, + 0xf10605deUL +#endif + } +}; diff --git a/zlib/src/deflate.c b/zlib/src/deflate.c new file mode 100644 index 0000000..6969577 --- /dev/null +++ b/zlib/src/deflate.c @@ -0,0 +1,1967 @@ +/* deflate.c -- compress data using the deflation algorithm + * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process depends on being able to identify portions + * of the input text which are identical to earlier input (within a + * sliding window trailing behind the input currently being processed). + * + * The most straightforward technique turns out to be the fastest for + * most input files: try all possible matches and select the longest. + * The key feature of this algorithm is that insertions into the string + * dictionary are very simple and thus fast, and deletions are avoided + * completely. Insertions are performed at each input character, whereas + * string matches are performed only when the previous match ends. So it + * is preferable to spend more time in matches to allow very fast string + * insertions and avoid deletions. The matching algorithm for small + * strings is inspired from that of Rabin & Karp. A brute force approach + * is used to find longer strings when a small match has been found. + * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze + * (by Leonid Broukhis). + * A previous version of this file used a more sophisticated algorithm + * (by Fiala and Greene) which is guaranteed to run in linear amortized + * time, but has a larger average cost, uses more memory and is patented. + * However the F&G algorithm may be faster for some highly redundant + * files if the parameter max_chain_length (described below) is too large. + * + * ACKNOWLEDGEMENTS + * + * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and + * I found it in 'freeze' written by Leonid Broukhis. + * Thanks to many people for bug reports and testing. + * + * REFERENCES + * + * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". + * Available in http://tools.ietf.org/html/rfc1951 + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. + * + * Fiala,E.R., and Greene,D.H. + * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 + * + */ + +/* @(#) $Id$ */ + +#include "deflate.h" + +const char deflate_copyright[] = + " deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* =========================================================================== + * Function prototypes. + */ +typedef enum { + need_more, /* block not completed, need more input or more output */ + block_done, /* block flush performed */ + finish_started, /* finish started, need only more output at next deflate */ + finish_done /* finish done, accept no more input or output */ +} block_state; + +typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +/* Compression function. Returns the block state after the call. */ + +local void fill_window OF((deflate_state *s)); +local block_state deflate_stored OF((deflate_state *s, int flush)); +local block_state deflate_fast OF((deflate_state *s, int flush)); +#ifndef FASTEST +local block_state deflate_slow OF((deflate_state *s, int flush)); +#endif +local block_state deflate_rle OF((deflate_state *s, int flush)); +local block_state deflate_huff OF((deflate_state *s, int flush)); +local void lm_init OF((deflate_state *s)); +local void putShortMSB OF((deflate_state *s, uInt b)); +local void flush_pending OF((z_streamp strm)); +local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +#ifdef ASMV + void match_init OF((void)); /* asm code initialization */ + uInt longest_match OF((deflate_state *s, IPos cur_match)); +#else +local uInt longest_match OF((deflate_state *s, IPos cur_match)); +#endif + +#ifdef DEBUG +local void check_match OF((deflate_state *s, IPos start, IPos match, + int length)); +#endif + +/* =========================================================================== + * Local data + */ + +#define NIL 0 +/* Tail of hash chains */ + +#ifndef TOO_FAR +# define TOO_FAR 4096 +#endif +/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +typedef struct config_s { + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; + compress_func func; +} config; + +#ifdef FASTEST +local const config configuration_table[2] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ +#else +local const config configuration_table[10] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ +/* 2 */ {4, 5, 16, 8, deflate_fast}, +/* 3 */ {4, 6, 32, 32, deflate_fast}, + +/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ +/* 5 */ {8, 16, 32, 32, deflate_slow}, +/* 6 */ {8, 16, 128, 128, deflate_slow}, +/* 7 */ {8, 32, 128, 256, deflate_slow}, +/* 8 */ {32, 128, 258, 1024, deflate_slow}, +/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ +#endif + +/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 + * For deflate_fast() (levels <= 3) good is ignored and lazy has a different + * meaning. + */ + +#define EQUAL 0 +/* result of memcmp for equal strings */ + +#ifndef NO_DUMMY_DECL +struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ +#endif + +/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */ +#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0)) + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) + + +/* =========================================================================== + * Insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * If this file is compiled with -DFASTEST, the compression level is forced + * to 1, and no hash chains are maintained. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of str are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +#ifdef FASTEST +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#else +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#endif + +/* =========================================================================== + * Initialize the hash table (avoiding 64K overflow for 16 bit systems). + * prev[] will be initialized on the fly. + */ +#define CLEAR_HASH(s) \ + s->head[s->hash_size-1] = NIL; \ + zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); + +/* ========================================================================= */ +int ZEXPORT deflateInit_(strm, level, version, stream_size) + z_streamp strm; + int level; + const char *version; + int stream_size; +{ + return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, version, stream_size); + /* To do: ignore strm->next_in if we use it as window */ +} + +/* ========================================================================= */ +int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + version, stream_size) + z_streamp strm; + int level; + int method; + int windowBits; + int memLevel; + int strategy; + const char *version; + int stream_size; +{ + deflate_state *s; + int wrap = 1; + static const char my_version[] = ZLIB_VERSION; + + ushf *overlay; + /* We overlay pending_buf and d_buf+l_buf. This works since the average + * output size for (length,distance) codes is <= 24 bits. + */ + + if (version == Z_NULL || version[0] != my_version[0] || + stream_size != sizeof(z_stream)) { + return Z_VERSION_ERROR; + } + if (strm == Z_NULL) return Z_STREAM_ERROR; + + strm->msg = Z_NULL; + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } +#ifdef GZIP + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } +#endif + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ + s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); + if (s == Z_NULL) return Z_MEM_ERROR; + strm->state = (struct internal_state FAR *)s; + s->strm = strm; + + s->wrap = wrap; + s->gzhead = Z_NULL; + s->w_bits = windowBits; + s->w_size = 1 << s->w_bits; + s->w_mask = s->w_size - 1; + + s->hash_bits = memLevel + 7; + s->hash_size = 1 << s->hash_bits; + s->hash_mask = s->hash_size - 1; + s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + + s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); + s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); + s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + + s->high_water = 0; /* nothing written to s->window yet */ + + s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + s->pending_buf = (uchf *) overlay; + s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); + + if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || + s->pending_buf == Z_NULL) { + s->status = FINISH_STATE; + strm->msg = ERR_MSG(Z_MEM_ERROR); + deflateEnd (strm); + return Z_MEM_ERROR; + } + s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + + s->level = level; + s->strategy = strategy; + s->method = (Byte)method; + + return deflateReset(strm); +} + +/* ========================================================================= */ +int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + z_streamp strm; + const Bytef *dictionary; + uInt dictLength; +{ + deflate_state *s; + uInt str, n; + int wrap; + unsigned avail; + z_const unsigned char *next; + + if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL) + return Z_STREAM_ERROR; + s = strm->state; + wrap = s->wrap; + if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) + return Z_STREAM_ERROR; + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap == 1) + strm->adler = adler32(strm->adler, dictionary, dictLength); + s->wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s->w_size) { + if (wrap == 0) { /* already empty otherwise */ + CLEAR_HASH(s); + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + dictionary += dictLength - s->w_size; /* use the tail */ + dictLength = s->w_size; + } + + /* insert dictionary into window and hash */ + avail = strm->avail_in; + next = strm->next_in; + strm->avail_in = dictLength; + strm->next_in = (z_const Bytef *)dictionary; + fill_window(s); + while (s->lookahead >= MIN_MATCH) { + str = s->strstart; + n = s->lookahead - (MIN_MATCH-1); + do { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + } while (--n); + s->strstart = str; + s->lookahead = MIN_MATCH-1; + fill_window(s); + } + s->strstart += s->lookahead; + s->block_start = (long)s->strstart; + s->insert = s->lookahead; + s->lookahead = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + strm->next_in = next; + strm->avail_in = avail; + s->wrap = wrap; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateResetKeep (strm) + z_streamp strm; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { + return Z_STREAM_ERROR; + } + + strm->total_in = strm->total_out = 0; + strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ + strm->data_type = Z_UNKNOWN; + + s = (deflate_state *)strm->state; + s->pending = 0; + s->pending_out = s->pending_buf; + + if (s->wrap < 0) { + s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ + } + s->status = s->wrap ? INIT_STATE : BUSY_STATE; + strm->adler = +#ifdef GZIP + s->wrap == 2 ? crc32(0L, Z_NULL, 0) : +#endif + adler32(0L, Z_NULL, 0); + s->last_flush = Z_NO_FLUSH; + + _tr_init(s); + + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateReset (strm) + z_streamp strm; +{ + int ret; + + ret = deflateResetKeep(strm); + if (ret == Z_OK) + lm_init(strm->state); + return ret; +} + +/* ========================================================================= */ +int ZEXPORT deflateSetHeader (strm, head) + z_streamp strm; + gz_headerp head; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (strm->state->wrap != 2) return Z_STREAM_ERROR; + strm->state->gzhead = head; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePending (strm, pending, bits) + unsigned *pending; + int *bits; + z_streamp strm; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (pending != Z_NULL) + *pending = strm->state->pending; + if (bits != Z_NULL) + *bits = strm->state->bi_valid; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePrime (strm, bits, value) + z_streamp strm; + int bits; + int value; +{ + deflate_state *s; + int put; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) + return Z_BUF_ERROR; + do { + put = Buf_size - s->bi_valid; + if (put > bits) + put = bits; + s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); + s->bi_valid += put; + _tr_flush_bits(s); + value >>= put; + bits -= put; + } while (bits); + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateParams(strm, level, strategy) + z_streamp strm; + int level; + int strategy; +{ + deflate_state *s; + compress_func func; + int err = Z_OK; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + func = configuration_table[s->level].func; + + if ((strategy != s->strategy || func != configuration_table[level].func) && + strm->total_in != 0) { + /* Flush the last buffer: */ + err = deflate(strm, Z_BLOCK); + if (err == Z_BUF_ERROR && s->pending == 0) + err = Z_OK; + } + if (s->level != level) { + s->level = level; + s->max_lazy_match = configuration_table[level].max_lazy; + s->good_match = configuration_table[level].good_length; + s->nice_match = configuration_table[level].nice_length; + s->max_chain_length = configuration_table[level].max_chain; + } + s->strategy = strategy; + return err; +} + +/* ========================================================================= */ +int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) + z_streamp strm; + int good_length; + int max_lazy; + int nice_length; + int max_chain; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + s->good_match = good_length; + s->max_lazy_match = max_lazy; + s->nice_match = nice_length; + s->max_chain_length = max_chain; + return Z_OK; +} + +/* ========================================================================= + * For the default windowBits of 15 and memLevel of 8, this function returns + * a close to exact, as well as small, upper bound on the compressed size. + * They are coded as constants here for a reason--if the #define's are + * changed, then this function needs to be changed as well. The return + * value for 15 and 8 only works for those exact settings. + * + * For any setting other than those defaults for windowBits and memLevel, + * the value returned is a conservative worst case for the maximum expansion + * resulting from using fixed blocks instead of stored blocks, which deflate + * can emit on compressed data for some combinations of the parameters. + * + * This function could be more sophisticated to provide closer upper bounds for + * every combination of windowBits and memLevel. But even the conservative + * upper bound of about 14% expansion does not seem onerous for output buffer + * allocation. + */ +uLong ZEXPORT deflateBound(strm, sourceLen) + z_streamp strm; + uLong sourceLen; +{ + deflate_state *s; + uLong complen, wraplen; + Bytef *str; + + /* conservative upper bound for compressed data */ + complen = sourceLen + + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; + + /* if can't get parameters, return conservative bound plus zlib wrapper */ + if (strm == Z_NULL || strm->state == Z_NULL) + return complen + 6; + + /* compute wrapper length */ + s = strm->state; + switch (s->wrap) { + case 0: /* raw deflate */ + wraplen = 0; + break; + case 1: /* zlib wrapper */ + wraplen = 6 + (s->strstart ? 4 : 0); + break; + case 2: /* gzip wrapper */ + wraplen = 18; + if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ + if (s->gzhead->extra != Z_NULL) + wraplen += 2 + s->gzhead->extra_len; + str = s->gzhead->name; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + str = s->gzhead->comment; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + if (s->gzhead->hcrc) + wraplen += 2; + } + break; + default: /* for compiler happiness */ + wraplen = 6; + } + + /* if not default parameters, return conservative bound */ + if (s->w_bits != 15 || s->hash_bits != 8 + 7) + return complen + wraplen; + + /* default settings: return tight bound for that case */ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13 - 6 + wraplen; +} + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +local void putShortMSB (s, b) + deflate_state *s; + uInt b; +{ + put_byte(s, (Byte)(b >> 8)); + put_byte(s, (Byte)(b & 0xff)); +} + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->next_out buffer and copying into it. + * (See also read_buf()). + */ +local void flush_pending(strm) + z_streamp strm; +{ + unsigned len; + deflate_state *s = strm->state; + + _tr_flush_bits(s); + len = s->pending; + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; + + zmemcpy(strm->next_out, s->pending_out, len); + strm->next_out += len; + s->pending_out += len; + strm->total_out += len; + strm->avail_out -= len; + s->pending -= len; + if (s->pending == 0) { + s->pending_out = s->pending_buf; + } +} + +/* ========================================================================= */ +int ZEXPORT deflate (strm, flush) + z_streamp strm; + int flush; +{ + int old_flush; /* value of flush param for previous deflate call */ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + flush > Z_BLOCK || flush < 0) { + return Z_STREAM_ERROR; + } + s = strm->state; + + if (strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0) || + (s->status == FINISH_STATE && flush != Z_FINISH)) { + ERR_RETURN(strm, Z_STREAM_ERROR); + } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); + + s->strm = strm; /* just in case */ + old_flush = s->last_flush; + s->last_flush = flush; + + /* Write the header */ + if (s->status == INIT_STATE) { +#ifdef GZIP + if (s->wrap == 2) { + strm->adler = crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (s->gzhead == Z_NULL) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s->status = BUSY_STATE; + } + else { + put_byte(s, (s->gzhead->text ? 1 : 0) + + (s->gzhead->hcrc ? 2 : 0) + + (s->gzhead->extra == Z_NULL ? 0 : 4) + + (s->gzhead->name == Z_NULL ? 0 : 8) + + (s->gzhead->comment == Z_NULL ? 0 : 16) + ); + put_byte(s, (Byte)(s->gzhead->time & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, s->gzhead->os & 0xff); + if (s->gzhead->extra != Z_NULL) { + put_byte(s, s->gzhead->extra_len & 0xff); + put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); + } + if (s->gzhead->hcrc) + strm->adler = crc32(strm->adler, s->pending_buf, + s->pending); + s->gzindex = 0; + s->status = EXTRA_STATE; + } + } + else +#endif + { + uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt level_flags; + + if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) + level_flags = 0; + else if (s->level < 6) + level_flags = 1; + else if (s->level == 6) + level_flags = 2; + else + level_flags = 3; + header |= (level_flags << 6); + if (s->strstart != 0) header |= PRESET_DICT; + header += 31 - (header % 31); + + s->status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s->strstart != 0) { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + strm->adler = adler32(0L, Z_NULL, 0); + } + } +#ifdef GZIP + if (s->status == EXTRA_STATE) { + if (s->gzhead->extra != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + + while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) + break; + } + put_byte(s, s->gzhead->extra[s->gzindex]); + s->gzindex++; + } + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (s->gzindex == s->gzhead->extra_len) { + s->gzindex = 0; + s->status = NAME_STATE; + } + } + else + s->status = NAME_STATE; + } + if (s->status == NAME_STATE) { + if (s->gzhead->name != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->name[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) { + s->gzindex = 0; + s->status = COMMENT_STATE; + } + } + else + s->status = COMMENT_STATE; + } + if (s->status == COMMENT_STATE) { + if (s->gzhead->comment != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->comment[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) + s->status = HCRC_STATE; + } + else + s->status = HCRC_STATE; + } + if (s->status == HCRC_STATE) { + if (s->gzhead->hcrc) { + if (s->pending + 2 > s->pending_buf_size) + flush_pending(strm); + if (s->pending + 2 <= s->pending_buf_size) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + strm->adler = crc32(0L, Z_NULL, 0); + s->status = BUSY_STATE; + } + } + else + s->status = BUSY_STATE; + } +#endif + + /* Flush as much pending output as possible */ + if (s->pending != 0) { + flush_pending(strm); + if (strm->avail_out == 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s->last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && + flush != Z_FINISH) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s->status == FINISH_STATE && strm->avail_in != 0) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm->avail_in != 0 || s->lookahead != 0 || + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + block_state bstate; + + bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : + (s->strategy == Z_RLE ? deflate_rle(s, flush) : + (*(configuration_table[s->level].func))(s, flush)); + + if (bstate == finish_started || bstate == finish_done) { + s->status = FINISH_STATE; + } + if (bstate == need_more || bstate == finish_started) { + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate == block_done) { + if (flush == Z_PARTIAL_FLUSH) { + _tr_align(s); + } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + _tr_stored_block(s, (char*)0, 0L, 0); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush == Z_FULL_FLUSH) { + CLEAR_HASH(s); /* forget history */ + if (s->lookahead == 0) { + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + } + } + flush_pending(strm); + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + Assert(strm->avail_out > 0, "bug2"); + + if (flush != Z_FINISH) return Z_OK; + if (s->wrap <= 0) return Z_STREAM_END; + + /* Write the trailer */ +#ifdef GZIP + if (s->wrap == 2) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); + put_byte(s, (Byte)(strm->total_in & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); + } + else +#endif + { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ + return s->pending != 0 ? Z_OK : Z_STREAM_END; +} + +/* ========================================================================= */ +int ZEXPORT deflateEnd (strm) + z_streamp strm; +{ + int status; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + + status = strm->state->status; + if (status != INIT_STATE && + status != EXTRA_STATE && + status != NAME_STATE && + status != COMMENT_STATE && + status != HCRC_STATE && + status != BUSY_STATE && + status != FINISH_STATE) { + return Z_STREAM_ERROR; + } + + /* Deallocate in reverse order of allocations: */ + TRY_FREE(strm, strm->state->pending_buf); + TRY_FREE(strm, strm->state->head); + TRY_FREE(strm, strm->state->prev); + TRY_FREE(strm, strm->state->window); + + ZFREE(strm, strm->state); + strm->state = Z_NULL; + + return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; +} + +/* ========================================================================= + * Copy the source state to the destination state. + * To simplify the source, this is not supported for 16-bit MSDOS (which + * doesn't have enough memory anyway to duplicate compression states). + */ +int ZEXPORT deflateCopy (dest, source) + z_streamp dest; + z_streamp source; +{ +#ifdef MAXSEG_64K + return Z_STREAM_ERROR; +#else + deflate_state *ds; + deflate_state *ss; + ushf *overlay; + + + if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { + return Z_STREAM_ERROR; + } + + ss = source->state; + + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + + ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; + dest->state = (struct internal_state FAR *) ds; + zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); + ds->strm = dest; + + ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); + ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); + ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); + ds->pending_buf = (uchf *) overlay; + + if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || + ds->pending_buf == Z_NULL) { + deflateEnd (dest); + return Z_MEM_ERROR; + } + /* following zmemcpy do not work for 16-bit MSDOS */ + zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); + zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); + zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); + zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); + + ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); + ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); + ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; + + ds->l_desc.dyn_tree = ds->dyn_ltree; + ds->d_desc.dyn_tree = ds->dyn_dtree; + ds->bl_desc.dyn_tree = ds->bl_tree; + + return Z_OK; +#endif /* MAXSEG_64K */ +} + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +local int read_buf(strm, buf, size) + z_streamp strm; + Bytef *buf; + unsigned size; +{ + unsigned len = strm->avail_in; + + if (len > size) len = size; + if (len == 0) return 0; + + strm->avail_in -= len; + + zmemcpy(buf, strm->next_in, len); + if (strm->state->wrap == 1) { + strm->adler = adler32(strm->adler, buf, len); + } +#ifdef GZIP + else if (strm->state->wrap == 2) { + strm->adler = crc32(strm->adler, buf, len); + } +#endif + strm->next_in += len; + strm->total_in += len; + + return (int)len; +} + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +local void lm_init (s) + deflate_state *s; +{ + s->window_size = (ulg)2L*s->w_size; + + CLEAR_HASH(s); + + /* Set the default configuration parameters: + */ + s->max_lazy_match = configuration_table[s->level].max_lazy; + s->good_match = configuration_table[s->level].good_length; + s->nice_match = configuration_table[s->level].nice_length; + s->max_chain_length = configuration_table[s->level].max_chain; + + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; + s->insert = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +#ifndef FASTEST +#ifdef ASMV + match_init(); /* initialize the asm code */ +#endif +#endif +} + +#ifndef FASTEST +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +#ifndef ASMV +/* For 80x86 and 680x0, an optimized version will be provided in match.asm or + * match.S. The code will be functionally equivalent. + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + int best_len = s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + Posf *prev = s->prev; + uInt wmask = s->w_mask; + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always beneficial. + * Try with and without -DUNALIGNED_OK to check. + */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register ush scan_start = *(ushf*)scan; + register ush scan_end = *(ushf*)(scan+best_len-1); +#else + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end = scan[best_len]; +#endif + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s->prev_length >= s->good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + Assert(cur_match < s->strstart, "no future"); + match = s->window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ushf*)(match+best_len-1) != scan_end || + *(ushf*)match != scan_start) continue; + + /* It is not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash keys + * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at + * strstart+3, +5, ... up to strstart+257. We check for insufficient + * lookahead only every 4th comparison; the 128th check will be made + * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * necessary to put more guard bytes at the end of the window, or + * to check more often for insufficient lookahead. + */ + Assert(scan[2] == match[2], "scan[2]?"); + scan++, match++; + do { + } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + if (*scan == *match) scan++; + + len = (MAX_MATCH - 1) - (int)(strend-scan); + scan = strend - (MAX_MATCH-1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len-1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + s->match_start = cur_match; + best_len = len; + if (len >= nice_match) break; +#ifdef UNALIGNED_OK + scan_end = *(ushf*)(scan+best_len-1); +#else + scan_end1 = scan[best_len-1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); + + if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; +} +#endif /* ASMV */ + +#else /* FASTEST */ + +/* --------------------------------------------------------------------------- + * Optimized version for FASTEST only + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + Assert(cur_match < s->strstart, "no future"); + + match = s->window + cur_match; + + /* Return failure if the match length is less than 2: + */ + if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match += 2; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + + if (len < MIN_MATCH) return MIN_MATCH - 1; + + s->match_start = cur_match; + return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; +} + +#endif /* FASTEST */ + +#ifdef DEBUG +/* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +local void check_match(s, start, match, length) + deflate_state *s; + IPos start, match; + int length; +{ + /* check that the match is indeed a match */ + if (zmemcmp(s->window + match, + s->window + start, length) != EQUAL) { + fprintf(stderr, " start %u, match %u, length %d\n", + start, match, length); + do { + fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); + } while (--length != 0); + z_error("invalid match"); + } + if (z_verbose > 1) { + fprintf(stderr,"\\[%d,%d]", start-match, length); + do { putc(s->window[start++], stderr); } while (--length != 0); + } +} +#else +# define check_match(s, start, match, length) +#endif /* DEBUG */ + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +local void fill_window(s) + deflate_state *s; +{ + register unsigned n, m; + register Posf *p; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + + Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + + /* Deal with !@#$% 64K limit: */ + if (sizeof(int) <= 2) { + if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + more = wsize; + + } else if (more == (unsigned)(-1)) { + /* Very unlikely, but possible on 16 bit machine if + * strstart == 0 && lookahead == 1 (input done a byte at time) + */ + more--; + } + } + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s->strstart >= wsize+MAX_DIST(s)) { + + zmemcpy(s->window, s->window+wsize, (unsigned)wsize); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (long) wsize; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + n = s->hash_size; + p = &s->head[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + } while (--n); + + n = wsize; +#ifndef FASTEST + p = &s->prev[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); +#endif + more += wsize; + } + if (s->strm->avail_in == 0) break; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + Assert(more >= 2, "more < 2"); + + n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s->lookahead + s->insert >= MIN_MATCH) { + uInt str = s->strstart - s->insert; + s->ins_h = s->window[str]; + UPDATE_HASH(s, s->ins_h, s->window[str + 1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + while (s->insert) { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + s->insert--; + if (s->lookahead + s->insert < MIN_MATCH) + break; + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ + if (s->high_water < s->window_size) { + ulg curr = s->strstart + (ulg)(s->lookahead); + ulg init; + + if (s->high_water < curr) { + /* Previous high water mark below current data -- zero WIN_INIT + * bytes or up to end of window, whichever is less. + */ + init = s->window_size - curr; + if (init > WIN_INIT) + init = WIN_INIT; + zmemzero(s->window + curr, (unsigned)init); + s->high_water = curr + init; + } + else if (s->high_water < (ulg)curr + WIN_INIT) { + /* High water mark at or above current data, but below current data + * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up + * to end of window, whichever is less. + */ + init = (ulg)curr + WIN_INIT - s->high_water; + if (init > s->window_size - s->high_water) + init = s->window_size - s->high_water; + zmemzero(s->window + s->high_water, (unsigned)init); + s->high_water += init; + } + } + + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "not enough room for search"); +} + +/* =========================================================================== + * Flush the current block, with given end-of-file flag. + * IN assertion: strstart is set to the end of the current match. + */ +#define FLUSH_BLOCK_ONLY(s, last) { \ + _tr_flush_block(s, (s->block_start >= 0L ? \ + (charf *)&s->window[(unsigned)s->block_start] : \ + (charf *)Z_NULL), \ + (ulg)((long)s->strstart - s->block_start), \ + (last)); \ + s->block_start = s->strstart; \ + flush_pending(s->strm); \ + Tracev((stderr,"[FLUSH]")); \ +} + +/* Same but force premature exit if necessary. */ +#define FLUSH_BLOCK(s, last) { \ + FLUSH_BLOCK_ONLY(s, last); \ + if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +local block_state deflate_stored(s, flush) + deflate_state *s; + int flush; +{ + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + ulg max_block_size = 0xffff; + ulg max_start; + + if (max_block_size > s->pending_buf_size - 5) { + max_block_size = s->pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s->lookahead <= 1) { + + Assert(s->strstart < s->w_size+MAX_DIST(s) || + s->block_start >= (long)s->w_size, "slide too late"); + + fill_window(s); + if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; + + if (s->lookahead == 0) break; /* flush the current block */ + } + Assert(s->block_start >= 0L, "block gone"); + + s->strstart += s->lookahead; + s->lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + max_start = s->block_start + max_block_size; + if (s->strstart == 0 || (ulg)s->strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s->lookahead = (uInt)(s->strstart - max_start); + s->strstart = (uInt)max_start; + FLUSH_BLOCK(s, 0); + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { + FLUSH_BLOCK(s, 0); + } + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if ((long)s->strstart > s->block_start) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +local block_state deflate_fast(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of the hash chain */ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + } + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->match_start, s->match_length); + + _tr_tally_dist(s, s->strstart - s->match_start, + s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ +#ifndef FASTEST + if (s->match_length <= s->max_insert_length && + s->lookahead >= MIN_MATCH) { + s->match_length--; /* string at strstart already in table */ + do { + s->strstart++; + INSERT_STRING(s, s->strstart, hash_head); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s->match_length != 0); + s->strstart++; + } else +#endif + { + s->strstart += s->match_length; + s->match_length = 0; + s->ins_h = s->window[s->strstart]; + UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +#ifndef FASTEST +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +local block_state deflate_slow(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of hash chain */ + int bflush; /* set if current block must be flushed */ + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + */ + s->prev_length = s->match_length, s->prev_match = s->match_start; + s->match_length = MIN_MATCH-1; + + if (hash_head != NIL && s->prev_length < s->max_lazy_match && + s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + + if (s->match_length <= 5 && (s->strategy == Z_FILTERED +#if TOO_FAR <= 32767 + || (s->match_length == MIN_MATCH && + s->strstart - s->match_start > TOO_FAR) +#endif + )) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s->match_length = MIN_MATCH-1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + check_match(s, s->strstart-1, s->prev_match, s->prev_length); + + _tr_tally_dist(s, s->strstart -1 - s->prev_match, + s->prev_length - MIN_MATCH, bflush); + + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s->lookahead -= s->prev_length-1; + s->prev_length -= 2; + do { + if (++s->strstart <= max_insert) { + INSERT_STRING(s, s->strstart, hash_head); + } + } while (--s->prev_length != 0); + s->match_available = 0; + s->match_length = MIN_MATCH-1; + s->strstart++; + + if (bflush) FLUSH_BLOCK(s, 0); + + } else if (s->match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + if (bflush) { + FLUSH_BLOCK_ONLY(s, 0); + } + s->strstart++; + s->lookahead--; + if (s->strm->avail_out == 0) return need_more; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s->match_available = 1; + s->strstart++; + s->lookahead--; + } + } + Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s->match_available) { + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + s->match_available = 0; + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} +#endif /* FASTEST */ + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +local block_state deflate_rle(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + uInt prev; /* byte at distance one to match */ + Bytef *scan, *strend; /* scan goes up to strend for length of run */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s->lookahead <= MAX_MATCH) { + fill_window(s); + if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s->match_length = 0; + if (s->lookahead >= MIN_MATCH && s->strstart > 0) { + scan = s->window + s->strstart - 1; + prev = *scan; + if (prev == *++scan && prev == *++scan && prev == *++scan) { + strend = s->window + s->strstart + MAX_MATCH; + do { + } while (prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + scan < strend); + s->match_length = MAX_MATCH - (int)(strend - scan); + if (s->match_length > s->lookahead) + s->match_length = s->lookahead; + } + Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->strstart - 1, s->match_length); + + _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + s->strstart += s->match_length; + s->match_length = 0; + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +local block_state deflate_huff(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s->lookahead == 0) { + fill_window(s); + if (s->lookahead == 0) { + if (flush == Z_NO_FLUSH) + return need_more; + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s->match_length = 0; + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} diff --git a/zlib/src/deflate.h b/zlib/src/deflate.h new file mode 100644 index 0000000..ce0299e --- /dev/null +++ b/zlib/src/deflate.h @@ -0,0 +1,346 @@ +/* deflate.h -- internal compression state + * Copyright (C) 1995-2012 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef DEFLATE_H +#define DEFLATE_H + +#include "zutil.h" + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer creation by deflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip encoding + should be left enabled. */ +#ifndef NO_GZIP +# define GZIP +#endif + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define Buf_size 16 +/* size of bit buffer in bi_buf */ + +#define INIT_STATE 42 +#define EXTRA_STATE 69 +#define NAME_STATE 73 +#define COMMENT_STATE 91 +#define HCRC_STATE 103 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + uInt pending; /* nb of bytes in the pending buffer */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + gz_headerp gzhead; /* gzip header information to write */ + uInt gzindex; /* where in extra, name, or comment */ + Byte method; /* can only be DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + long block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to suppress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + uInt insert; /* bytes at end of window left to insert */ + +#ifdef DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + ulg high_water; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + +#define WIN_INIT MAX_MATCH +/* Number of bytes after end of data in window to initialize in order to avoid + memory checker errors from longest match routines */ + + /* in trees.c */ +void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); +int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); +void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch ZLIB_INTERNAL _length_code[]; + extern uch ZLIB_INTERNAL _dist_code[]; +#else + extern const uch ZLIB_INTERNAL _length_code[]; + extern const uch ZLIB_INTERNAL _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif /* DEFLATE_H */ diff --git a/zlib/src/gzclose.c b/zlib/src/gzclose.c new file mode 100644 index 0000000..caeb99a --- /dev/null +++ b/zlib/src/gzclose.c @@ -0,0 +1,25 @@ +/* gzclose.c -- zlib gzclose() function + * Copyright (C) 2004, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "gzguts.h" + +/* gzclose() is in a separate file so that it is linked in only if it is used. + That way the other gzclose functions can be used instead to avoid linking in + unneeded compression or decompression routines. */ +int ZEXPORT gzclose(file) + gzFile file; +{ +#ifndef NO_GZCOMPRESS + gz_statep state; + + if (file == NULL) + return Z_STREAM_ERROR; + state = (gz_statep)file; + + return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file); +#else + return gzclose_r(file); +#endif +} diff --git a/zlib/src/gzguts.h b/zlib/src/gzguts.h new file mode 100644 index 0000000..d87659d --- /dev/null +++ b/zlib/src/gzguts.h @@ -0,0 +1,209 @@ +/* gzguts.h -- zlib internal header definitions for gz* operations + * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifdef _LARGEFILE64_SOURCE +# ifndef _LARGEFILE_SOURCE +# define _LARGEFILE_SOURCE 1 +# endif +# ifdef _FILE_OFFSET_BITS +# undef _FILE_OFFSET_BITS +# endif +#endif + +#ifdef HAVE_HIDDEN +# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#else +# define ZLIB_INTERNAL +#endif + +#include +#include "zlib.h" +#ifdef STDC +# include +# include +# include +#endif +#include + +#ifdef _WIN32 +# include +#endif + +#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) +# include +#endif + +#ifdef WINAPI_FAMILY +# define open _open +# define read _read +# define write _write +# define close _close +#endif + +#ifdef NO_DEFLATE /* for compatibility with old definition */ +# define NO_GZCOMPRESS +#endif + +#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(__CYGWIN__) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#ifndef HAVE_VSNPRINTF +# ifdef MSDOS +/* vsnprintf may exist on some MS-DOS compilers (DJGPP?), + but for now we just assume it doesn't. */ +# define NO_vsnprintf +# endif +# ifdef __TURBOC__ +# define NO_vsnprintf +# endif +# ifdef WIN32 +/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +# if !defined(vsnprintf) && !defined(NO_vsnprintf) +# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) +# define vsnprintf _vsnprintf +# endif +# endif +# endif +# ifdef __SASC +# define NO_vsnprintf +# endif +# ifdef VMS +# define NO_vsnprintf +# endif +# ifdef __OS400__ +# define NO_vsnprintf +# endif +# ifdef __MVS__ +# define NO_vsnprintf +# endif +#endif + +/* unlike snprintf (which is required in C99, yet still not supported by + Microsoft more than a decade later!), _snprintf does not guarantee null + termination of the result -- however this is only used in gzlib.c where + the result is assured to fit in the space provided */ +#ifdef _MSC_VER +# define snprintf _snprintf +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +/* gz* functions always use library allocation functions */ +#ifndef STDC + extern voidp malloc OF((uInt size)); + extern void free OF((voidpf ptr)); +#endif + +/* get errno and strerror definition */ +#if defined UNDER_CE +# include +# define zstrerror() gz_strwinerror((DWORD)GetLastError()) +#else +# ifndef NO_STRERROR +# include +# define zstrerror() strerror(errno) +# else +# define zstrerror() "stdio error (consult errno)" +# endif +#endif + +/* provide prototypes for these when building zlib without LFS */ +#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +#endif + +/* default memLevel */ +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif + +/* default i/o buffer size -- double this for output when reading (this and + twice this must be able to fit in an unsigned type) */ +#define GZBUFSIZE 8192 + +/* gzip modes, also provide a little integrity check on the passed structure */ +#define GZ_NONE 0 +#define GZ_READ 7247 +#define GZ_WRITE 31153 +#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ + +/* values for gz_state how */ +#define LOOK 0 /* look for a gzip header */ +#define COPY 1 /* copy input directly */ +#define GZIP 2 /* decompress a gzip stream */ + +/* internal gzip file state data structure */ +typedef struct { + /* exposed contents for gzgetc() macro */ + struct gzFile_s x; /* "x" for exposed */ + /* x.have: number of bytes available at x.next */ + /* x.next: next output data to deliver or write */ + /* x.pos: current position in uncompressed data */ + /* used for both reading and writing */ + int mode; /* see gzip modes above */ + int fd; /* file descriptor */ + char *path; /* path or fd for error messages */ + unsigned size; /* buffer size, zero if not allocated yet */ + unsigned want; /* requested buffer size, default is GZBUFSIZE */ + unsigned char *in; /* input buffer */ + unsigned char *out; /* output buffer (double-sized when reading) */ + int direct; /* 0 if processing gzip, 1 if transparent */ + /* just for reading */ + int how; /* 0: get header, 1: copy, 2: decompress */ + z_off64_t start; /* where the gzip data started, for rewinding */ + int eof; /* true if end of input file reached */ + int past; /* true if read requested past end */ + /* just for writing */ + int level; /* compression level */ + int strategy; /* compression strategy */ + /* seek request */ + z_off64_t skip; /* amount to skip (already rewound if backwards) */ + int seek; /* true if seek request pending */ + /* error information */ + int err; /* error code */ + char *msg; /* error message */ + /* zlib inflate or deflate stream */ + z_stream strm; /* stream structure in-place (not a pointer) */ +} gz_state; +typedef gz_state FAR *gz_statep; + +/* shared functions */ +void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +#if defined UNDER_CE +char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +#endif + +/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t + value -- needed when comparing unsigned to z_off64_t, which is signed + (possible z_off64_t types off_t, off64_t, and long are all signed) */ +#ifdef INT_MAX +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) +#else +unsigned ZLIB_INTERNAL gz_intmax OF((void)); +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) +#endif diff --git a/zlib/src/gzlib.c b/zlib/src/gzlib.c new file mode 100644 index 0000000..fae202e --- /dev/null +++ b/zlib/src/gzlib.c @@ -0,0 +1,634 @@ +/* gzlib.c -- zlib functions common to reading and writing gzip files + * Copyright (C) 2004, 2010, 2011, 2012, 2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "gzguts.h" + +#if defined(_WIN32) && !defined(__BORLANDC__) +# define LSEEK _lseeki64 +#else +#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 +# define LSEEK lseek64 +#else +# define LSEEK lseek +#endif +#endif + +/* Local functions */ +local void gz_reset OF((gz_statep)); +local gzFile gz_open OF((const void *, int, const char *)); + +#if defined UNDER_CE + +/* Map the Windows error number in ERROR to a locale-dependent error message + string and return a pointer to it. Typically, the values for ERROR come + from GetLastError. + + The string pointed to shall not be modified by the application, but may be + overwritten by a subsequent call to gz_strwinerror + + The gz_strwinerror function does not change the current setting of + GetLastError. */ +char ZLIB_INTERNAL *gz_strwinerror (error) + DWORD error; +{ + static char buf[1024]; + + wchar_t *msgbuf; + DWORD lasterr = GetLastError(); + DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM + | FORMAT_MESSAGE_ALLOCATE_BUFFER, + NULL, + error, + 0, /* Default language */ + (LPVOID)&msgbuf, + 0, + NULL); + if (chars != 0) { + /* If there is an \r\n appended, zap it. */ + if (chars >= 2 + && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') { + chars -= 2; + msgbuf[chars] = 0; + } + + if (chars > sizeof (buf) - 1) { + chars = sizeof (buf) - 1; + msgbuf[chars] = 0; + } + + wcstombs(buf, msgbuf, chars + 1); + LocalFree(msgbuf); + } + else { + sprintf(buf, "unknown win32 error (%ld)", error); + } + + SetLastError(lasterr); + return buf; +} + +#endif /* UNDER_CE */ + +/* Reset gzip file state */ +local void gz_reset(state) + gz_statep state; +{ + state->x.have = 0; /* no output data available */ + if (state->mode == GZ_READ) { /* for reading ... */ + state->eof = 0; /* not at end of file */ + state->past = 0; /* have not read past end yet */ + state->how = LOOK; /* look for gzip header */ + } + state->seek = 0; /* no seek request pending */ + gz_error(state, Z_OK, NULL); /* clear error */ + state->x.pos = 0; /* no uncompressed data yet */ + state->strm.avail_in = 0; /* no input data yet */ +} + +/* Open a gzip file either by name or file descriptor. */ +local gzFile gz_open(path, fd, mode) + const void *path; + int fd; + const char *mode; +{ + gz_statep state; + size_t len; + int oflag; +#ifdef O_CLOEXEC + int cloexec = 0; +#endif +#ifdef O_EXCL + int exclusive = 0; +#endif + + /* check input */ + if (path == NULL) + return NULL; + + /* allocate gzFile structure to return */ + state = (gz_statep)malloc(sizeof(gz_state)); + if (state == NULL) + return NULL; + state->size = 0; /* no buffers allocated yet */ + state->want = GZBUFSIZE; /* requested buffer size */ + state->msg = NULL; /* no error message yet */ + + /* interpret mode */ + state->mode = GZ_NONE; + state->level = Z_DEFAULT_COMPRESSION; + state->strategy = Z_DEFAULT_STRATEGY; + state->direct = 0; + while (*mode) { + if (*mode >= '0' && *mode <= '9') + state->level = *mode - '0'; + else + switch (*mode) { + case 'r': + state->mode = GZ_READ; + break; +#ifndef NO_GZCOMPRESS + case 'w': + state->mode = GZ_WRITE; + break; + case 'a': + state->mode = GZ_APPEND; + break; +#endif + case '+': /* can't read and write at the same time */ + free(state); + return NULL; + case 'b': /* ignore -- will request binary anyway */ + break; +#ifdef O_CLOEXEC + case 'e': + cloexec = 1; + break; +#endif +#ifdef O_EXCL + case 'x': + exclusive = 1; + break; +#endif + case 'f': + state->strategy = Z_FILTERED; + break; + case 'h': + state->strategy = Z_HUFFMAN_ONLY; + break; + case 'R': + state->strategy = Z_RLE; + break; + case 'F': + state->strategy = Z_FIXED; + break; + case 'T': + state->direct = 1; + break; + default: /* could consider as an error, but just ignore */ + ; + } + mode++; + } + + /* must provide an "r", "w", or "a" */ + if (state->mode == GZ_NONE) { + free(state); + return NULL; + } + + /* can't force transparent read */ + if (state->mode == GZ_READ) { + if (state->direct) { + free(state); + return NULL; + } + state->direct = 1; /* for empty file */ + } + + /* save the path name for error messages */ +#ifdef _WIN32 + if (fd == -2) { + len = wcstombs(NULL, path, 0); + if (len == (size_t)-1) + len = 0; + } + else +#endif + len = strlen((const char *)path); + state->path = (char *)malloc(len + 1); + if (state->path == NULL) { + free(state); + return NULL; + } +#ifdef _WIN32 + if (fd == -2) + if (len) + wcstombs(state->path, path, len + 1); + else + *(state->path) = 0; + else +#endif +#if !defined(NO_snprintf) && !defined(NO_vsnprintf) + snprintf(state->path, len + 1, "%s", (const char *)path); +#else + strcpy(state->path, path); +#endif + + /* compute the flags for open() */ + oflag = +#ifdef O_LARGEFILE + O_LARGEFILE | +#endif +#ifdef O_BINARY + O_BINARY | +#endif +#ifdef O_CLOEXEC + (cloexec ? O_CLOEXEC : 0) | +#endif + (state->mode == GZ_READ ? + O_RDONLY : + (O_WRONLY | O_CREAT | +#ifdef O_EXCL + (exclusive ? O_EXCL : 0) | +#endif + (state->mode == GZ_WRITE ? + O_TRUNC : + O_APPEND))); + + /* open the file with the appropriate flags (or just use fd) */ + state->fd = fd > -1 ? fd : ( +#ifdef _WIN32 + fd == -2 ? _wopen(path, oflag, 0666) : +#endif + open((const char *)path, oflag, 0666)); + if (state->fd == -1) { + free(state->path); + free(state); + return NULL; + } + if (state->mode == GZ_APPEND) + state->mode = GZ_WRITE; /* simplify later checks */ + + /* save the current position for rewinding (only if reading) */ + if (state->mode == GZ_READ) { + state->start = LSEEK(state->fd, 0, SEEK_CUR); + if (state->start == -1) state->start = 0; + } + + /* initialize stream */ + gz_reset(state); + + /* return stream */ + return (gzFile)state; +} + +/* -- see zlib.h -- */ +gzFile ZEXPORT gzopen(path, mode) + const char *path; + const char *mode; +{ + return gz_open(path, -1, mode); +} + +/* -- see zlib.h -- */ +gzFile ZEXPORT gzopen64(path, mode) + const char *path; + const char *mode; +{ + return gz_open(path, -1, mode); +} + +/* -- see zlib.h -- */ +gzFile ZEXPORT gzdopen(fd, mode) + int fd; + const char *mode; +{ + char *path; /* identifier for error messages */ + gzFile gz; + + if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL) + return NULL; +#if !defined(NO_snprintf) && !defined(NO_vsnprintf) + snprintf(path, 7 + 3 * sizeof(int), "", fd); /* for debugging */ +#else + sprintf(path, "", fd); /* for debugging */ +#endif + gz = gz_open(path, fd, mode); + free(path); + return gz; +} + +/* -- see zlib.h -- */ +#ifdef _WIN32 +gzFile ZEXPORT gzopen_w(path, mode) + const wchar_t *path; + const char *mode; +{ + return gz_open(path, -2, mode); +} +#endif + +/* -- see zlib.h -- */ +int ZEXPORT gzbuffer(file, size) + gzFile file; + unsigned size; +{ + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return -1; + + /* make sure we haven't already allocated memory */ + if (state->size != 0) + return -1; + + /* check and set requested size */ + if (size < 2) + size = 2; /* need two bytes to check magic header */ + state->want = size; + return 0; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzrewind(file) + gzFile file; +{ + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + + /* check that we're reading and that there's no error */ + if (state->mode != GZ_READ || + (state->err != Z_OK && state->err != Z_BUF_ERROR)) + return -1; + + /* back up and start over */ + if (LSEEK(state->fd, state->start, SEEK_SET) == -1) + return -1; + gz_reset(state); + return 0; +} + +/* -- see zlib.h -- */ +z_off64_t ZEXPORT gzseek64(file, offset, whence) + gzFile file; + z_off64_t offset; + int whence; +{ + unsigned n; + z_off64_t ret; + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return -1; + + /* check that there's no error */ + if (state->err != Z_OK && state->err != Z_BUF_ERROR) + return -1; + + /* can only seek from start or relative to current position */ + if (whence != SEEK_SET && whence != SEEK_CUR) + return -1; + + /* normalize offset to a SEEK_CUR specification */ + if (whence == SEEK_SET) + offset -= state->x.pos; + else if (state->seek) + offset += state->skip; + state->seek = 0; + + /* if within raw area while reading, just go there */ + if (state->mode == GZ_READ && state->how == COPY && + state->x.pos + offset >= 0) { + ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR); + if (ret == -1) + return -1; + state->x.have = 0; + state->eof = 0; + state->past = 0; + state->seek = 0; + gz_error(state, Z_OK, NULL); + state->strm.avail_in = 0; + state->x.pos += offset; + return state->x.pos; + } + + /* calculate skip amount, rewinding if needed for back seek when reading */ + if (offset < 0) { + if (state->mode != GZ_READ) /* writing -- can't go backwards */ + return -1; + offset += state->x.pos; + if (offset < 0) /* before start of file! */ + return -1; + if (gzrewind(file) == -1) /* rewind, then skip to offset */ + return -1; + } + + /* if reading, skip what's in output buffer (one less gzgetc() check) */ + if (state->mode == GZ_READ) { + n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ? + (unsigned)offset : state->x.have; + state->x.have -= n; + state->x.next += n; + state->x.pos += n; + offset -= n; + } + + /* request skip (if not zero) */ + if (offset) { + state->seek = 1; + state->skip = offset; + } + return state->x.pos + offset; +} + +/* -- see zlib.h -- */ +z_off_t ZEXPORT gzseek(file, offset, whence) + gzFile file; + z_off_t offset; + int whence; +{ + z_off64_t ret; + + ret = gzseek64(file, (z_off64_t)offset, whence); + return ret == (z_off_t)ret ? (z_off_t)ret : -1; +} + +/* -- see zlib.h -- */ +z_off64_t ZEXPORT gztell64(file) + gzFile file; +{ + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return -1; + + /* return position */ + return state->x.pos + (state->seek ? state->skip : 0); +} + +/* -- see zlib.h -- */ +z_off_t ZEXPORT gztell(file) + gzFile file; +{ + z_off64_t ret; + + ret = gztell64(file); + return ret == (z_off_t)ret ? (z_off_t)ret : -1; +} + +/* -- see zlib.h -- */ +z_off64_t ZEXPORT gzoffset64(file) + gzFile file; +{ + z_off64_t offset; + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return -1; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return -1; + + /* compute and return effective offset in file */ + offset = LSEEK(state->fd, 0, SEEK_CUR); + if (offset == -1) + return -1; + if (state->mode == GZ_READ) /* reading */ + offset -= state->strm.avail_in; /* don't count buffered input */ + return offset; +} + +/* -- see zlib.h -- */ +z_off_t ZEXPORT gzoffset(file) + gzFile file; +{ + z_off64_t ret; + + ret = gzoffset64(file); + return ret == (z_off_t)ret ? (z_off_t)ret : -1; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzeof(file) + gzFile file; +{ + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return 0; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return 0; + + /* return end-of-file state */ + return state->mode == GZ_READ ? state->past : 0; +} + +/* -- see zlib.h -- */ +const char * ZEXPORT gzerror(file, errnum) + gzFile file; + int *errnum; +{ + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return NULL; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return NULL; + + /* return error information */ + if (errnum != NULL) + *errnum = state->err; + return state->err == Z_MEM_ERROR ? "out of memory" : + (state->msg == NULL ? "" : state->msg); +} + +/* -- see zlib.h -- */ +void ZEXPORT gzclearerr(file) + gzFile file; +{ + gz_statep state; + + /* get internal structure and check integrity */ + if (file == NULL) + return; + state = (gz_statep)file; + if (state->mode != GZ_READ && state->mode != GZ_WRITE) + return; + + /* clear error and end-of-file */ + if (state->mode == GZ_READ) { + state->eof = 0; + state->past = 0; + } + gz_error(state, Z_OK, NULL); +} + +/* Create an error message in allocated memory and set state->err and + state->msg accordingly. Free any previous error message already there. Do + not try to free or allocate space if the error is Z_MEM_ERROR (out of + memory). Simply save the error message as a static string. If there is an + allocation failure constructing the error message, then convert the error to + out of memory. */ +void ZLIB_INTERNAL gz_error(state, err, msg) + gz_statep state; + int err; + const char *msg; +{ + /* free previously allocated message and clear */ + if (state->msg != NULL) { + if (state->err != Z_MEM_ERROR) + free(state->msg); + state->msg = NULL; + } + + /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */ + if (err != Z_OK && err != Z_BUF_ERROR) + state->x.have = 0; + + /* set error code, and if no message, then done */ + state->err = err; + if (msg == NULL) + return; + + /* for an out of memory error, return literal string when requested */ + if (err == Z_MEM_ERROR) + return; + + /* construct error message with path */ + if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) == + NULL) { + state->err = Z_MEM_ERROR; + return; + } +#if !defined(NO_snprintf) && !defined(NO_vsnprintf) + snprintf(state->msg, strlen(state->path) + strlen(msg) + 3, + "%s%s%s", state->path, ": ", msg); +#else + strcpy(state->msg, state->path); + strcat(state->msg, ": "); + strcat(state->msg, msg); +#endif + return; +} + +#ifndef INT_MAX +/* portably return maximum value for an int (when limits.h presumed not + available) -- we need to do this to cover cases where 2's complement not + used, since C standard permits 1's complement and sign-bit representations, + otherwise we could just use ((unsigned)-1) >> 1 */ +unsigned ZLIB_INTERNAL gz_intmax() +{ + unsigned p, q; + + p = 1; + do { + q = p; + p <<= 1; + p++; + } while (p > q); + return q >> 1; +} +#endif diff --git a/zlib/src/gzread.c b/zlib/src/gzread.c new file mode 100644 index 0000000..bf4538e --- /dev/null +++ b/zlib/src/gzread.c @@ -0,0 +1,594 @@ +/* gzread.c -- zlib functions for reading gzip files + * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "gzguts.h" + +/* Local functions */ +local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); +local int gz_avail OF((gz_statep)); +local int gz_look OF((gz_statep)); +local int gz_decomp OF((gz_statep)); +local int gz_fetch OF((gz_statep)); +local int gz_skip OF((gz_statep, z_off64_t)); + +/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from + state->fd, and update state->eof, state->err, and state->msg as appropriate. + This function needs to loop on read(), since read() is not guaranteed to + read the number of bytes requested, depending on the type of descriptor. */ +local int gz_load(state, buf, len, have) + gz_statep state; + unsigned char *buf; + unsigned len; + unsigned *have; +{ + int ret; + + *have = 0; + do { + ret = read(state->fd, buf + *have, len - *have); + if (ret <= 0) + break; + *have += ret; + } while (*have < len); + if (ret < 0) { + gz_error(state, Z_ERRNO, zstrerror()); + return -1; + } + if (ret == 0) + state->eof = 1; + return 0; +} + +/* Load up input buffer and set eof flag if last data loaded -- return -1 on + error, 0 otherwise. Note that the eof flag is set when the end of the input + file is reached, even though there may be unused data in the buffer. Once + that data has been used, no more attempts will be made to read the file. + If strm->avail_in != 0, then the current data is moved to the beginning of + the input buffer, and then the remainder of the buffer is loaded with the + available data from the input file. */ +local int gz_avail(state) + gz_statep state; +{ + unsigned got; + z_streamp strm = &(state->strm); + + if (state->err != Z_OK && state->err != Z_BUF_ERROR) + return -1; + if (state->eof == 0) { + if (strm->avail_in) { /* copy what's there to the start */ + unsigned char *p = state->in; + unsigned const char *q = strm->next_in; + unsigned n = strm->avail_in; + do { + *p++ = *q++; + } while (--n); + } + if (gz_load(state, state->in + strm->avail_in, + state->size - strm->avail_in, &got) == -1) + return -1; + strm->avail_in += got; + strm->next_in = state->in; + } + return 0; +} + +/* Look for gzip header, set up for inflate or copy. state->x.have must be 0. + If this is the first time in, allocate required memory. state->how will be + left unchanged if there is no more input data available, will be set to COPY + if there is no gzip header and direct copying will be performed, or it will + be set to GZIP for decompression. If direct copying, then leftover input + data from the input buffer will be copied to the output buffer. In that + case, all further file reads will be directly to either the output buffer or + a user buffer. If decompressing, the inflate state will be initialized. + gz_look() will return 0 on success or -1 on failure. */ +local int gz_look(state) + gz_statep state; +{ + z_streamp strm = &(state->strm); + + /* allocate read buffers and inflate memory */ + if (state->size == 0) { + /* allocate buffers */ + state->in = (unsigned char *)malloc(state->want); + state->out = (unsigned char *)malloc(state->want << 1); + if (state->in == NULL || state->out == NULL) { + if (state->out != NULL) + free(state->out); + if (state->in != NULL) + free(state->in); + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + state->size = state->want; + + /* allocate inflate memory */ + state->strm.zalloc = Z_NULL; + state->strm.zfree = Z_NULL; + state->strm.opaque = Z_NULL; + state->strm.avail_in = 0; + state->strm.next_in = Z_NULL; + if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */ + free(state->out); + free(state->in); + state->size = 0; + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + } + + /* get at least the magic bytes in the input buffer */ + if (strm->avail_in < 2) { + if (gz_avail(state) == -1) + return -1; + if (strm->avail_in == 0) + return 0; + } + + /* look for gzip magic bytes -- if there, do gzip decoding (note: there is + a logical dilemma here when considering the case of a partially written + gzip file, to wit, if a single 31 byte is written, then we cannot tell + whether this is a single-byte file, or just a partially written gzip + file -- for here we assume that if a gzip file is being written, then + the header will be written in a single operation, so that reading a + single byte is sufficient indication that it is not a gzip file) */ + if (strm->avail_in > 1 && + strm->next_in[0] == 31 && strm->next_in[1] == 139) { + inflateReset(strm); + state->how = GZIP; + state->direct = 0; + return 0; + } + + /* no gzip header -- if we were decoding gzip before, then this is trailing + garbage. Ignore the trailing garbage and finish. */ + if (state->direct == 0) { + strm->avail_in = 0; + state->eof = 1; + state->x.have = 0; + return 0; + } + + /* doing raw i/o, copy any leftover input to output -- this assumes that + the output buffer is larger than the input buffer, which also assures + space for gzungetc() */ + state->x.next = state->out; + if (strm->avail_in) { + memcpy(state->x.next, strm->next_in, strm->avail_in); + state->x.have = strm->avail_in; + strm->avail_in = 0; + } + state->how = COPY; + state->direct = 1; + return 0; +} + +/* Decompress from input to the provided next_out and avail_out in the state. + On return, state->x.have and state->x.next point to the just decompressed + data. If the gzip stream completes, state->how is reset to LOOK to look for + the next gzip stream or raw data, once state->x.have is depleted. Returns 0 + on success, -1 on failure. */ +local int gz_decomp(state) + gz_statep state; +{ + int ret = Z_OK; + unsigned had; + z_streamp strm = &(state->strm); + + /* fill output buffer up to end of deflate stream */ + had = strm->avail_out; + do { + /* get more input for inflate() */ + if (strm->avail_in == 0 && gz_avail(state) == -1) + return -1; + if (strm->avail_in == 0) { + gz_error(state, Z_BUF_ERROR, "unexpected end of file"); + break; + } + + /* decompress and handle errors */ + ret = inflate(strm, Z_NO_FLUSH); + if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) { + gz_error(state, Z_STREAM_ERROR, + "internal error: inflate stream corrupt"); + return -1; + } + if (ret == Z_MEM_ERROR) { + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + if (ret == Z_DATA_ERROR) { /* deflate stream invalid */ + gz_error(state, Z_DATA_ERROR, + strm->msg == NULL ? "compressed data error" : strm->msg); + return -1; + } + } while (strm->avail_out && ret != Z_STREAM_END); + + /* update available output */ + state->x.have = had - strm->avail_out; + state->x.next = strm->next_out - state->x.have; + + /* if the gzip stream completed successfully, look for another */ + if (ret == Z_STREAM_END) + state->how = LOOK; + + /* good decompression */ + return 0; +} + +/* Fetch data and put it in the output buffer. Assumes state->x.have is 0. + Data is either copied from the input file or decompressed from the input + file depending on state->how. If state->how is LOOK, then a gzip header is + looked for to determine whether to copy or decompress. Returns -1 on error, + otherwise 0. gz_fetch() will leave state->how as COPY or GZIP unless the + end of the input file has been reached and all data has been processed. */ +local int gz_fetch(state) + gz_statep state; +{ + z_streamp strm = &(state->strm); + + do { + switch(state->how) { + case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */ + if (gz_look(state) == -1) + return -1; + if (state->how == LOOK) + return 0; + break; + case COPY: /* -> COPY */ + if (gz_load(state, state->out, state->size << 1, &(state->x.have)) + == -1) + return -1; + state->x.next = state->out; + return 0; + case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */ + strm->avail_out = state->size << 1; + strm->next_out = state->out; + if (gz_decomp(state) == -1) + return -1; + } + } while (state->x.have == 0 && (!state->eof || strm->avail_in)); + return 0; +} + +/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */ +local int gz_skip(state, len) + gz_statep state; + z_off64_t len; +{ + unsigned n; + + /* skip over len bytes or reach end-of-file, whichever comes first */ + while (len) + /* skip over whatever is in output buffer */ + if (state->x.have) { + n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ? + (unsigned)len : state->x.have; + state->x.have -= n; + state->x.next += n; + state->x.pos += n; + len -= n; + } + + /* output buffer empty -- return if we're at the end of the input */ + else if (state->eof && state->strm.avail_in == 0) + break; + + /* need more data to skip -- load up output buffer */ + else { + /* get more output, looking for header if required */ + if (gz_fetch(state) == -1) + return -1; + } + return 0; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzread(file, buf, len) + gzFile file; + voidp buf; + unsigned len; +{ + unsigned got, n; + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that we're reading and that there's no (serious) error */ + if (state->mode != GZ_READ || + (state->err != Z_OK && state->err != Z_BUF_ERROR)) + return -1; + + /* since an int is returned, make sure len fits in one, otherwise return + with an error (this avoids the flaw in the interface) */ + if ((int)len < 0) { + gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); + return -1; + } + + /* if len is zero, avoid unnecessary operations */ + if (len == 0) + return 0; + + /* process a skip request */ + if (state->seek) { + state->seek = 0; + if (gz_skip(state, state->skip) == -1) + return -1; + } + + /* get len bytes to buf, or less than len if at the end */ + got = 0; + do { + /* first just try copying data from the output buffer */ + if (state->x.have) { + n = state->x.have > len ? len : state->x.have; + memcpy(buf, state->x.next, n); + state->x.next += n; + state->x.have -= n; + } + + /* output buffer empty -- return if we're at the end of the input */ + else if (state->eof && strm->avail_in == 0) { + state->past = 1; /* tried to read past end */ + break; + } + + /* need output data -- for small len or new stream load up our output + buffer */ + else if (state->how == LOOK || len < (state->size << 1)) { + /* get more output, looking for header if required */ + if (gz_fetch(state) == -1) + return -1; + continue; /* no progress yet -- go back to copy above */ + /* the copy above assures that we will leave with space in the + output buffer, allowing at least one gzungetc() to succeed */ + } + + /* large len -- read directly into user buffer */ + else if (state->how == COPY) { /* read directly */ + if (gz_load(state, (unsigned char *)buf, len, &n) == -1) + return -1; + } + + /* large len -- decompress directly into user buffer */ + else { /* state->how == GZIP */ + strm->avail_out = len; + strm->next_out = (unsigned char *)buf; + if (gz_decomp(state) == -1) + return -1; + n = state->x.have; + state->x.have = 0; + } + + /* update progress */ + len -= n; + buf = (char *)buf + n; + got += n; + state->x.pos += n; + } while (len); + + /* return number of bytes read into user buffer (will fit in int) */ + return (int)got; +} + +/* -- see zlib.h -- */ +#ifdef Z_PREFIX_SET +# undef z_gzgetc +#else +# undef gzgetc +#endif +int ZEXPORT gzgetc(file) + gzFile file; +{ + int ret; + unsigned char buf[1]; + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + + /* check that we're reading and that there's no (serious) error */ + if (state->mode != GZ_READ || + (state->err != Z_OK && state->err != Z_BUF_ERROR)) + return -1; + + /* try output buffer (no need to check for skip request) */ + if (state->x.have) { + state->x.have--; + state->x.pos++; + return *(state->x.next)++; + } + + /* nothing there -- try gzread() */ + ret = gzread(file, buf, 1); + return ret < 1 ? -1 : buf[0]; +} + +int ZEXPORT gzgetc_(file) +gzFile file; +{ + return gzgetc(file); +} + +/* -- see zlib.h -- */ +int ZEXPORT gzungetc(c, file) + int c; + gzFile file; +{ + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + + /* check that we're reading and that there's no (serious) error */ + if (state->mode != GZ_READ || + (state->err != Z_OK && state->err != Z_BUF_ERROR)) + return -1; + + /* process a skip request */ + if (state->seek) { + state->seek = 0; + if (gz_skip(state, state->skip) == -1) + return -1; + } + + /* can't push EOF */ + if (c < 0) + return -1; + + /* if output buffer empty, put byte at end (allows more pushing) */ + if (state->x.have == 0) { + state->x.have = 1; + state->x.next = state->out + (state->size << 1) - 1; + state->x.next[0] = c; + state->x.pos--; + state->past = 0; + return c; + } + + /* if no room, give up (must have already done a gzungetc()) */ + if (state->x.have == (state->size << 1)) { + gz_error(state, Z_DATA_ERROR, "out of room to push characters"); + return -1; + } + + /* slide output data if needed and insert byte before existing data */ + if (state->x.next == state->out) { + unsigned char *src = state->out + state->x.have; + unsigned char *dest = state->out + (state->size << 1); + while (src > state->out) + *--dest = *--src; + state->x.next = dest; + } + state->x.have++; + state->x.next--; + state->x.next[0] = c; + state->x.pos--; + state->past = 0; + return c; +} + +/* -- see zlib.h -- */ +char * ZEXPORT gzgets(file, buf, len) + gzFile file; + char *buf; + int len; +{ + unsigned left, n; + char *str; + unsigned char *eol; + gz_statep state; + + /* check parameters and get internal structure */ + if (file == NULL || buf == NULL || len < 1) + return NULL; + state = (gz_statep)file; + + /* check that we're reading and that there's no (serious) error */ + if (state->mode != GZ_READ || + (state->err != Z_OK && state->err != Z_BUF_ERROR)) + return NULL; + + /* process a skip request */ + if (state->seek) { + state->seek = 0; + if (gz_skip(state, state->skip) == -1) + return NULL; + } + + /* copy output bytes up to new line or len - 1, whichever comes first -- + append a terminating zero to the string (we don't check for a zero in + the contents, let the user worry about that) */ + str = buf; + left = (unsigned)len - 1; + if (left) do { + /* assure that something is in the output buffer */ + if (state->x.have == 0 && gz_fetch(state) == -1) + return NULL; /* error */ + if (state->x.have == 0) { /* end of file */ + state->past = 1; /* read past end */ + break; /* return what we have */ + } + + /* look for end-of-line in current output buffer */ + n = state->x.have > left ? left : state->x.have; + eol = (unsigned char *)memchr(state->x.next, '\n', n); + if (eol != NULL) + n = (unsigned)(eol - state->x.next) + 1; + + /* copy through end-of-line, or remainder if not found */ + memcpy(buf, state->x.next, n); + state->x.have -= n; + state->x.next += n; + state->x.pos += n; + left -= n; + buf += n; + } while (left && eol == NULL); + + /* return terminated string, or if nothing, end of file */ + if (buf == str) + return NULL; + buf[0] = 0; + return str; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzdirect(file) + gzFile file; +{ + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return 0; + state = (gz_statep)file; + + /* if the state is not known, but we can find out, then do so (this is + mainly for right after a gzopen() or gzdopen()) */ + if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0) + (void)gz_look(state); + + /* return 1 if transparent, 0 if processing a gzip stream */ + return state->direct; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzclose_r(file) + gzFile file; +{ + int ret, err; + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return Z_STREAM_ERROR; + state = (gz_statep)file; + + /* check that we're reading */ + if (state->mode != GZ_READ) + return Z_STREAM_ERROR; + + /* free memory and close file */ + if (state->size) { + inflateEnd(&(state->strm)); + free(state->out); + free(state->in); + } + err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK; + gz_error(state, Z_OK, NULL); + free(state->path); + ret = close(state->fd); + free(state); + return ret ? Z_ERRNO : err; +} diff --git a/zlib/src/gzwrite.c b/zlib/src/gzwrite.c new file mode 100644 index 0000000..aa767fb --- /dev/null +++ b/zlib/src/gzwrite.c @@ -0,0 +1,577 @@ +/* gzwrite.c -- zlib functions for writing gzip files + * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "gzguts.h" + +/* Local functions */ +local int gz_init OF((gz_statep)); +local int gz_comp OF((gz_statep, int)); +local int gz_zero OF((gz_statep, z_off64_t)); + +/* Initialize state for writing a gzip file. Mark initialization by setting + state->size to non-zero. Return -1 on failure or 0 on success. */ +local int gz_init(state) + gz_statep state; +{ + int ret; + z_streamp strm = &(state->strm); + + /* allocate input buffer */ + state->in = (unsigned char *)malloc(state->want); + if (state->in == NULL) { + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + + /* only need output buffer and deflate state if compressing */ + if (!state->direct) { + /* allocate output buffer */ + state->out = (unsigned char *)malloc(state->want); + if (state->out == NULL) { + free(state->in); + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + + /* allocate deflate memory, set up for gzip compression */ + strm->zalloc = Z_NULL; + strm->zfree = Z_NULL; + strm->opaque = Z_NULL; + ret = deflateInit2(strm, state->level, Z_DEFLATED, + MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy); + if (ret != Z_OK) { + free(state->out); + free(state->in); + gz_error(state, Z_MEM_ERROR, "out of memory"); + return -1; + } + } + + /* mark state as initialized */ + state->size = state->want; + + /* initialize write buffer if compressing */ + if (!state->direct) { + strm->avail_out = state->size; + strm->next_out = state->out; + state->x.next = strm->next_out; + } + return 0; +} + +/* Compress whatever is at avail_in and next_in and write to the output file. + Return -1 if there is an error writing to the output file, otherwise 0. + flush is assumed to be a valid deflate() flush value. If flush is Z_FINISH, + then the deflate() state is reset to start a new gzip stream. If gz->direct + is true, then simply write to the output file without compressing, and + ignore flush. */ +local int gz_comp(state, flush) + gz_statep state; + int flush; +{ + int ret, got; + unsigned have; + z_streamp strm = &(state->strm); + + /* allocate memory if this is the first time through */ + if (state->size == 0 && gz_init(state) == -1) + return -1; + + /* write directly if requested */ + if (state->direct) { + got = write(state->fd, strm->next_in, strm->avail_in); + if (got < 0 || (unsigned)got != strm->avail_in) { + gz_error(state, Z_ERRNO, zstrerror()); + return -1; + } + strm->avail_in = 0; + return 0; + } + + /* run deflate() on provided input until it produces no more output */ + ret = Z_OK; + do { + /* write out current buffer contents if full, or if flushing, but if + doing Z_FINISH then don't write until we get to Z_STREAM_END */ + if (strm->avail_out == 0 || (flush != Z_NO_FLUSH && + (flush != Z_FINISH || ret == Z_STREAM_END))) { + have = (unsigned)(strm->next_out - state->x.next); + if (have && ((got = write(state->fd, state->x.next, have)) < 0 || + (unsigned)got != have)) { + gz_error(state, Z_ERRNO, zstrerror()); + return -1; + } + if (strm->avail_out == 0) { + strm->avail_out = state->size; + strm->next_out = state->out; + } + state->x.next = strm->next_out; + } + + /* compress */ + have = strm->avail_out; + ret = deflate(strm, flush); + if (ret == Z_STREAM_ERROR) { + gz_error(state, Z_STREAM_ERROR, + "internal error: deflate stream corrupt"); + return -1; + } + have -= strm->avail_out; + } while (have); + + /* if that completed a deflate stream, allow another to start */ + if (flush == Z_FINISH) + deflateReset(strm); + + /* all done, no errors */ + return 0; +} + +/* Compress len zeros to output. Return -1 on error, 0 on success. */ +local int gz_zero(state, len) + gz_statep state; + z_off64_t len; +{ + int first; + unsigned n; + z_streamp strm = &(state->strm); + + /* consume whatever's left in the input buffer */ + if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) + return -1; + + /* compress len zeros (len guaranteed > 0) */ + first = 1; + while (len) { + n = GT_OFF(state->size) || (z_off64_t)state->size > len ? + (unsigned)len : state->size; + if (first) { + memset(state->in, 0, n); + first = 0; + } + strm->avail_in = n; + strm->next_in = state->in; + state->x.pos += n; + if (gz_comp(state, Z_NO_FLUSH) == -1) + return -1; + len -= n; + } + return 0; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzwrite(file, buf, len) + gzFile file; + voidpc buf; + unsigned len; +{ + unsigned put = len; + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return 0; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return 0; + + /* since an int is returned, make sure len fits in one, otherwise return + with an error (this avoids the flaw in the interface) */ + if ((int)len < 0) { + gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); + return 0; + } + + /* if len is zero, avoid unnecessary operations */ + if (len == 0) + return 0; + + /* allocate memory if this is the first time through */ + if (state->size == 0 && gz_init(state) == -1) + return 0; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return 0; + } + + /* for small len, copy to input buffer, otherwise compress directly */ + if (len < state->size) { + /* copy to input buffer, compress when full */ + do { + unsigned have, copy; + + if (strm->avail_in == 0) + strm->next_in = state->in; + have = (unsigned)((strm->next_in + strm->avail_in) - state->in); + copy = state->size - have; + if (copy > len) + copy = len; + memcpy(state->in + have, buf, copy); + strm->avail_in += copy; + state->x.pos += copy; + buf = (const char *)buf + copy; + len -= copy; + if (len && gz_comp(state, Z_NO_FLUSH) == -1) + return 0; + } while (len); + } + else { + /* consume whatever's left in the input buffer */ + if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) + return 0; + + /* directly compress user buffer to file */ + strm->avail_in = len; + strm->next_in = (z_const Bytef *)buf; + state->x.pos += len; + if (gz_comp(state, Z_NO_FLUSH) == -1) + return 0; + } + + /* input was all buffered or compressed (put will fit in int) */ + return (int)put; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzputc(file, c) + gzFile file; + int c; +{ + unsigned have; + unsigned char buf[1]; + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return -1; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return -1; + } + + /* try writing to input buffer for speed (state->size == 0 if buffer not + initialized) */ + if (state->size) { + if (strm->avail_in == 0) + strm->next_in = state->in; + have = (unsigned)((strm->next_in + strm->avail_in) - state->in); + if (have < state->size) { + state->in[have] = c; + strm->avail_in++; + state->x.pos++; + return c & 0xff; + } + } + + /* no room in buffer or not initialized, use gz_write() */ + buf[0] = c; + if (gzwrite(file, buf, 1) != 1) + return -1; + return c & 0xff; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzputs(file, str) + gzFile file; + const char *str; +{ + int ret; + unsigned len; + + /* write string */ + len = (unsigned)strlen(str); + ret = gzwrite(file, str, len); + return ret == 0 && len != 0 ? -1 : ret; +} + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +#include + +/* -- see zlib.h -- */ +int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va) +{ + int size, len; + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return 0; + + /* make sure we have some buffer space */ + if (state->size == 0 && gz_init(state) == -1) + return 0; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return 0; + } + + /* consume whatever's left in the input buffer */ + if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) + return 0; + + /* do the printf() into the input buffer, put length in len */ + size = (int)(state->size); + state->in[size - 1] = 0; +#ifdef NO_vsnprintf +# ifdef HAS_vsprintf_void + (void)vsprintf((char *)(state->in), format, va); + for (len = 0; len < size; len++) + if (state->in[len] == 0) break; +# else + len = vsprintf((char *)(state->in), format, va); +# endif +#else +# ifdef HAS_vsnprintf_void + (void)vsnprintf((char *)(state->in), size, format, va); + len = strlen((char *)(state->in)); +# else + len = vsnprintf((char *)(state->in), size, format, va); +# endif +#endif + + /* check that printf() results fit in buffer */ + if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) + return 0; + + /* update buffer and position, defer compression until needed */ + strm->avail_in = (unsigned)len; + strm->next_in = state->in; + state->x.pos += len; + return len; +} + +int ZEXPORTVA gzprintf(gzFile file, const char *format, ...) +{ + va_list va; + int ret; + + va_start(va, format); + ret = gzvprintf(file, format, va); + va_end(va); + return ret; +} + +#else /* !STDC && !Z_HAVE_STDARG_H */ + +/* -- see zlib.h -- */ +int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, + a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) + gzFile file; + const char *format; + int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, + a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; +{ + int size, len; + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that can really pass pointer in ints */ + if (sizeof(int) != sizeof(void *)) + return 0; + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return 0; + + /* make sure we have some buffer space */ + if (state->size == 0 && gz_init(state) == -1) + return 0; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return 0; + } + + /* consume whatever's left in the input buffer */ + if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1) + return 0; + + /* do the printf() into the input buffer, put length in len */ + size = (int)(state->size); + state->in[size - 1] = 0; +#ifdef NO_snprintf +# ifdef HAS_sprintf_void + sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + for (len = 0; len < size; len++) + if (state->in[len] == 0) break; +# else + len = sprintf((char *)(state->in), format, a1, a2, a3, a4, a5, a6, a7, a8, + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); +# endif +#else +# ifdef HAS_snprintf_void + snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8, + a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); + len = strlen((char *)(state->in)); +# else + len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, + a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, + a19, a20); +# endif +#endif + + /* check that printf() results fit in buffer */ + if (len <= 0 || len >= (int)size || state->in[size - 1] != 0) + return 0; + + /* update buffer and position, defer compression until needed */ + strm->avail_in = (unsigned)len; + strm->next_in = state->in; + state->x.pos += len; + return len; +} + +#endif + +/* -- see zlib.h -- */ +int ZEXPORT gzflush(file, flush) + gzFile file; + int flush; +{ + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return -1; + state = (gz_statep)file; + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return Z_STREAM_ERROR; + + /* check flush parameter */ + if (flush < 0 || flush > Z_FINISH) + return Z_STREAM_ERROR; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return -1; + } + + /* compress remaining data with requested flush */ + gz_comp(state, flush); + return state->err; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzsetparams(file, level, strategy) + gzFile file; + int level; + int strategy; +{ + gz_statep state; + z_streamp strm; + + /* get internal structure */ + if (file == NULL) + return Z_STREAM_ERROR; + state = (gz_statep)file; + strm = &(state->strm); + + /* check that we're writing and that there's no error */ + if (state->mode != GZ_WRITE || state->err != Z_OK) + return Z_STREAM_ERROR; + + /* if no change is requested, then do nothing */ + if (level == state->level && strategy == state->strategy) + return Z_OK; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + return -1; + } + + /* change compression parameters for subsequent input */ + if (state->size) { + /* flush previous input with previous parameters before changing */ + if (strm->avail_in && gz_comp(state, Z_PARTIAL_FLUSH) == -1) + return state->err; + deflateParams(strm, level, strategy); + } + state->level = level; + state->strategy = strategy; + return Z_OK; +} + +/* -- see zlib.h -- */ +int ZEXPORT gzclose_w(file) + gzFile file; +{ + int ret = Z_OK; + gz_statep state; + + /* get internal structure */ + if (file == NULL) + return Z_STREAM_ERROR; + state = (gz_statep)file; + + /* check that we're writing */ + if (state->mode != GZ_WRITE) + return Z_STREAM_ERROR; + + /* check for seek request */ + if (state->seek) { + state->seek = 0; + if (gz_zero(state, state->skip) == -1) + ret = state->err; + } + + /* flush, free memory, and close file */ + if (gz_comp(state, Z_FINISH) == -1) + ret = state->err; + if (state->size) { + if (!state->direct) { + (void)deflateEnd(&(state->strm)); + free(state->out); + } + free(state->in); + } + gz_error(state, Z_OK, NULL); + free(state->path); + if (close(state->fd) == -1) + ret = Z_ERRNO; + free(state); + return ret; +} diff --git a/zlib/src/infback.c b/zlib/src/infback.c new file mode 100644 index 0000000..f3833c2 --- /dev/null +++ b/zlib/src/infback.c @@ -0,0 +1,640 @@ +/* infback.c -- inflate using a call-back interface + * Copyright (C) 1995-2011 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + This code is largely copied from inflate.c. Normally either infback.o or + inflate.o would be linked into an application--not both. The interface + with inffast.c is retained so that optimized assembler-coded versions of + inflate_fast() can be used with either inflate.c or infback.c. + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +/* function prototypes */ +local void fixedtables OF((struct inflate_state FAR *state)); + +/* + strm provides memory allocation functions in zalloc and zfree, or + Z_NULL to use the library memory allocation functions. + + windowBits is in the range 8..15, and window is a user-supplied + window and output buffer that is 2**windowBits bytes. + */ +int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) +z_streamp strm; +int windowBits; +unsigned char FAR *window; +const char *version; +int stream_size; +{ + struct inflate_state FAR *state; + + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != (int)(sizeof(z_stream))) + return Z_VERSION_ERROR; + if (strm == Z_NULL || window == Z_NULL || + windowBits < 8 || windowBits > 15) + return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + state = (struct inflate_state FAR *)ZALLOC(strm, 1, + sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + state->dmax = 32768U; + state->wbits = windowBits; + state->wsize = 1U << windowBits; + state->window = window; + state->wnext = 0; + state->whave = 0; + return Z_OK; +} + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +local void fixedtables(state) +struct inflate_state FAR *state; +{ +#ifdef BUILDFIXED + static int virgin = 1; + static code *lenfix, *distfix; + static code fixed[544]; + + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + unsigned sym, bits; + static code *next; + + /* literal/length table */ + sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; + lenfix = next; + bits = 9; + inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); + + /* distance table */ + sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; + bits = 5; + inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); + + /* do this just once */ + virgin = 0; + } +#else /* !BUILDFIXED */ +# include "inffixed.h" +#endif /* BUILDFIXED */ + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + +/* Macros for inflateBack(): */ + +/* Load returned state from inflate_fast() */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Set state from registers for inflate_fast() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Assure that some input is available. If input is requested, but denied, + then return a Z_BUF_ERROR from inflateBack(). */ +#define PULL() \ + do { \ + if (have == 0) { \ + have = in(in_desc, &next); \ + if (have == 0) { \ + next = Z_NULL; \ + ret = Z_BUF_ERROR; \ + goto inf_leave; \ + } \ + } \ + } while (0) + +/* Get a byte of input into the bit accumulator, or return from inflateBack() + with an error if there is no input available. */ +#define PULLBYTE() \ + do { \ + PULL(); \ + have--; \ + hold += (unsigned long)(*next++) << bits; \ + bits += 8; \ + } while (0) + +/* Assure that there are at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflateBack() with + an error. */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + ((unsigned)hold & ((1U << (n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +/* Assure that some output space is available, by writing out the window + if it's full. If the write fails, return from inflateBack() with a + Z_BUF_ERROR. */ +#define ROOM() \ + do { \ + if (left == 0) { \ + put = state->window; \ + left = state->wsize; \ + state->whave = left; \ + if (out(out_desc, put, left)) { \ + ret = Z_BUF_ERROR; \ + goto inf_leave; \ + } \ + } \ + } while (0) + +/* + strm provides the memory allocation functions and window buffer on input, + and provides information on the unused input on return. For Z_DATA_ERROR + returns, strm will also provide an error message. + + in() and out() are the call-back input and output functions. When + inflateBack() needs more input, it calls in(). When inflateBack() has + filled the window with output, or when it completes with data in the + window, it calls out() to write out the data. The application must not + change the provided input until in() is called again or inflateBack() + returns. The application must not change the window/output buffer until + inflateBack() returns. + + in() and out() are called with a descriptor parameter provided in the + inflateBack() call. This parameter can be a structure that provides the + information required to do the read or write, as well as accumulated + information on the input and output such as totals and check values. + + in() should return zero on failure. out() should return non-zero on + failure. If either in() or out() fails, than inflateBack() returns a + Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it + was in() or out() that caused in the error. Otherwise, inflateBack() + returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format + error, or Z_MEM_ERROR if it could not allocate memory for the state. + inflateBack() can also return Z_STREAM_ERROR if the input parameters + are not correct, i.e. strm is Z_NULL or the state was not initialized. + */ +int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) +z_streamp strm; +in_func in; +void FAR *in_desc; +out_func out; +void FAR *out_desc; +{ + struct inflate_state FAR *state; + z_const unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned long hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char FAR *from; /* where to copy match bytes from */ + code here; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int ret; /* return code */ + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + /* Check that the strm exists and that the state was initialized */ + if (strm == Z_NULL || strm->state == Z_NULL) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* Reset the state */ + strm->msg = Z_NULL; + state->mode = TYPE; + state->last = 0; + state->whave = 0; + next = strm->next_in; + have = next != Z_NULL ? strm->avail_in : 0; + hold = 0; + bits = 0; + put = state->window; + left = state->wsize; + + /* Inflate until end of block marked as last */ + for (;;) + switch (state->mode) { + case TYPE: + /* determine and dispatch block type */ + if (state->last) { + BYTEBITS(); + state->mode = DONE; + break; + } + NEEDBITS(3); + state->last = BITS(1); + DROPBITS(1); + switch (BITS(2)) { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN; /* decode codes */ + break; + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + case 3: + strm->msg = (char *)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); + break; + + case STORED: + /* get and verify stored block length */ + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { + strm->msg = (char *)"invalid stored block lengths"; + state->mode = BAD; + break; + } + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + + /* copy stored block from input to output */ + while (state->length != 0) { + copy = state->length; + PULL(); + ROOM(); + if (copy > have) copy = have; + if (copy > left) copy = left; + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + } + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + + case TABLE: + /* get dynamic table entries descriptor */ + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) { + strm->msg = (char *)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + + /* get code length code lengths (not a typo) */ + state->have = 0; + while (state->have < state->ncode) { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + + /* get length and distance code code lengths */ + state->have = 0; + while (state->have < state->nlen + state->ndist) { + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.val < 16) { + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } + else { + if (here.val == 16) { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + if (state->have == 0) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + len = (unsigned)(state->lens[state->have - 1]); + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + if (state->have + copy > state->nlen + state->ndist) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + while (copy--) + state->lens[state->have++] = (unsigned short)len; + } + } + + /* handle error breaks in while */ + if (state->mode == BAD) break; + + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) { + strm->msg = (char *)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (code const FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + if (ret) { + strm->msg = (char *)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN; + + case LEN: + /* use inflate_fast() if we have enough input and output */ + if (have >= 6 && left >= 258) { + RESTORE(); + if (state->whave < state->wsize) + state->whave = state->wsize - left; + inflate_fast(strm, state->wsize); + LOAD(); + break; + } + + /* get a literal, length, or end-of-block code */ + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.op && (here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + } + DROPBITS(here.bits); + state->length = (unsigned)here.val; + + /* process literal */ + if (here.op == 0) { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + ROOM(); + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + } + + /* process end of block */ + if (here.op & 32) { + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + + /* invalid code */ + if (here.op & 64) { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + + /* length code -- get extra bits, if any */ + state->extra = (unsigned)(here.op) & 15; + if (state->extra != 0) { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + + /* get distance code */ + for (;;) { + here = state->distcode[BITS(state->distbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if ((here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + } + DROPBITS(here.bits); + if (here.op & 64) { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)here.val; + + /* get distance extra bits, if any */ + state->extra = (unsigned)(here.op) & 15; + if (state->extra != 0) { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + } + if (state->offset > state->wsize - (state->whave < state->wsize ? + left : 0)) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + + /* copy match from window to output */ + do { + ROOM(); + copy = state->wsize - state->offset; + if (copy < left) { + from = put + copy; + copy = left - copy; + } + else { + from = put - state->offset; + copy = left; + } + if (copy > state->length) copy = state->length; + state->length -= copy; + left -= copy; + do { + *put++ = *from++; + } while (--copy); + } while (state->length != 0); + break; + + case DONE: + /* inflate stream terminated properly -- write leftover output */ + ret = Z_STREAM_END; + if (left < state->wsize) { + if (out(out_desc, state->window, state->wsize - left)) + ret = Z_BUF_ERROR; + } + goto inf_leave; + + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + + default: /* can't happen, but makes compilers happy */ + ret = Z_STREAM_ERROR; + goto inf_leave; + } + + /* Return unused input */ + inf_leave: + strm->next_in = next; + strm->avail_in = have; + return ret; +} + +int ZEXPORT inflateBackEnd(strm) +z_streamp strm; +{ + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) + return Z_STREAM_ERROR; + ZFREE(strm, strm->state); + strm->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} diff --git a/zlib/src/inffast.c b/zlib/src/inffast.c new file mode 100644 index 0000000..bda59ce --- /dev/null +++ b/zlib/src/inffast.c @@ -0,0 +1,340 @@ +/* inffast.c -- fast decoding + * Copyright (C) 1995-2008, 2010, 2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifndef ASMINF + +/* Allow machine dependent optimization for post-increment or pre-increment. + Based on testing to date, + Pre-increment preferred for: + - PowerPC G3 (Adler) + - MIPS R5000 (Randers-Pehrson) + Post-increment preferred for: + - none + No measurable difference: + - Pentium III (Anderson) + - M68060 (Nikl) + */ +#ifdef POSTINC +# define OFF 0 +# define PUP(a) *(a)++ +#else +# define OFF 1 +# define PUP(a) *++(a) +#endif + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state->mode == LEN + strm->avail_in >= 6 + strm->avail_out >= 258 + start >= strm->avail_out + state->bits < 8 + + On return, state->mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm->avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm->avail_out >= 258 for each loop to avoid checking for + output space. + */ +void ZLIB_INTERNAL inflate_fast(strm, start) +z_streamp strm; +unsigned start; /* inflate()'s starting value for strm->avail_out */ +{ + struct inflate_state FAR *state; + z_const unsigned char FAR *in; /* local strm->next_in */ + z_const unsigned char FAR *last; /* have enough input while in < last */ + unsigned char FAR *out; /* local strm->next_out */ + unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR *end; /* while out < end, enough space available */ +#ifdef INFLATE_STRICT + unsigned dmax; /* maximum distance from zlib header */ +#endif + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ + unsigned long hold; /* local strm->hold */ + unsigned bits; /* local strm->bits */ + code const FAR *lcode; /* local strm->lencode */ + code const FAR *dcode; /* local strm->distcode */ + unsigned lmask; /* mask for first level of length codes */ + unsigned dmask; /* mask for first level of distance codes */ + code here; /* retrieved table entry */ + unsigned op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + unsigned len; /* match length, unused bytes */ + unsigned dist; /* match distance */ + unsigned char FAR *from; /* where to copy match from */ + + /* copy state to local variables */ + state = (struct inflate_state FAR *)strm->state; + in = strm->next_in - OFF; + last = in + (strm->avail_in - 5); + out = strm->next_out - OFF; + beg = out - (start - strm->avail_out); + end = out + (strm->avail_out - 257); +#ifdef INFLATE_STRICT + dmax = state->dmax; +#endif + wsize = state->wsize; + whave = state->whave; + wnext = state->wnext; + window = state->window; + hold = state->hold; + bits = state->bits; + lcode = state->lencode; + dcode = state->distcode; + lmask = (1U << state->lenbits) - 1; + dmask = (1U << state->distbits) - 1; + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + do { + if (bits < 15) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op == 0) { /* literal */ + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + PUP(out) = (unsigned char)(here.val); + } + else if (op & 16) { /* length base */ + len = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + len += (unsigned)hold & ((1U << op) - 1); + hold >>= op; + bits -= op; + } + Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op & 16) { /* distance base */ + dist = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + if (bits < op) { + hold += (unsigned long)(PUP(in)) << bits; + bits += 8; + } + } + dist += (unsigned)hold & ((1U << op) - 1); +#ifdef INFLATE_STRICT + if (dist > dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + hold >>= op; + bits -= op; + Tracevv((stderr, "inflate: distance %u\n", dist)); + op = (unsigned)(out - beg); /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state->sane) { + strm->msg = + (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + if (len <= op - whave) { + do { + PUP(out) = 0; + } while (--len); + continue; + } + len -= op - whave; + do { + PUP(out) = 0; + } while (--op > whave); + if (op == 0) { + from = out - dist; + do { + PUP(out) = PUP(from); + } while (--len); + continue; + } +#endif + } + from = window - OFF; + if (wnext == 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = window - OFF; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + while (len > 2) { + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + else { + from = out - dist; /* copy direct from output */ + do { /* minimum length is three */ + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } while (len > 2); + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + } + else if ((op & 64) == 0) { /* 2nd level distance code */ + here = dcode[here.val + (hold & ((1U << op) - 1))]; + goto dodist; + } + else { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + } + else if ((op & 64) == 0) { /* 2nd level length code */ + here = lcode[here.val + (hold & ((1U << op) - 1))]; + goto dolen; + } + else if (op & 32) { /* end-of-block */ + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + else { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + } while (in < last && out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + in -= len; + bits -= len << 3; + hold &= (1U << bits) - 1; + + /* update state and return */ + strm->next_in = in + OFF; + strm->next_out = out + OFF; + strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); + strm->avail_out = (unsigned)(out < end ? + 257 + (end - out) : 257 - (out - end)); + state->hold = hold; + state->bits = bits; + return; +} + +/* + inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): + - Using bit fields for code structure + - Different op definition to avoid & for extra bits (do & for table bits) + - Three separate decoding do-loops for direct, window, and wnext == 0 + - Special case for distance > 1 copies to do overlapped load and store copy + - Explicit branch predictions (based on measured branch probabilities) + - Deferring match copy and interspersed it with decoding subsequent codes + - Swapping literal/length else + - Swapping window/direct else + - Larger unrolled copy loops (three is about right) + - Moving len -= 3 statement into middle of loop + */ + +#endif /* !ASMINF */ diff --git a/zlib/src/inffast.h b/zlib/src/inffast.h new file mode 100644 index 0000000..e5c1aa4 --- /dev/null +++ b/zlib/src/inffast.h @@ -0,0 +1,11 @@ +/* inffast.h -- header to use inffast.c + * Copyright (C) 1995-2003, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); diff --git a/zlib/src/inffixed.h b/zlib/src/inffixed.h new file mode 100644 index 0000000..d628327 --- /dev/null +++ b/zlib/src/inffixed.h @@ -0,0 +1,94 @@ + /* inffixed.h -- table for decoding fixed codes + * Generated automatically by makefixed(). + */ + + /* WARNING: this file should *not* be used by applications. + It is part of the implementation of this library and is + subject to change. Applications should only use zlib.h. + */ + + static const code lenfix[512] = { + {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, + {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, + {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, + {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, + {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, + {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, + {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, + {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, + {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, + {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, + {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, + {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, + {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, + {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, + {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, + {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, + {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, + {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, + {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, + {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, + {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, + {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, + {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, + {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, + {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, + {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, + {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, + {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, + {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, + {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, + {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, + {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, + {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, + {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, + {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, + {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, + {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, + {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, + {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, + {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, + {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, + {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, + {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, + {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, + {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, + {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, + {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, + {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, + {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, + {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, + {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, + {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, + {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, + {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, + {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, + {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, + {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, + {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, + {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, + {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, + {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, + {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, + {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, + {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, + {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, + {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, + {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, + {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, + {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, + {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, + {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, + {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, + {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, + {0,9,255} + }; + + static const code distfix[32] = { + {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, + {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, + {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, + {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, + {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, + {22,5,193},{64,5,0} + }; diff --git a/zlib/src/inflate.c b/zlib/src/inflate.c new file mode 100644 index 0000000..870f89b --- /dev/null +++ b/zlib/src/inflate.c @@ -0,0 +1,1512 @@ +/* inflate.c -- zlib decompression + * Copyright (C) 1995-2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * Change history: + * + * 1.2.beta0 24 Nov 2002 + * - First version -- complete rewrite of inflate to simplify code, avoid + * creation of window when not needed, minimize use of window when it is + * needed, make inffast.c even faster, implement gzip decoding, and to + * improve code readability and style over the previous zlib inflate code + * + * 1.2.beta1 25 Nov 2002 + * - Use pointers for available input and output checking in inffast.c + * - Remove input and output counters in inffast.c + * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 + * - Remove unnecessary second byte pull from length extra in inffast.c + * - Unroll direct copy to three copies per loop in inffast.c + * + * 1.2.beta2 4 Dec 2002 + * - Change external routine names to reduce potential conflicts + * - Correct filename to inffixed.h for fixed tables in inflate.c + * - Make hbuf[] unsigned char to match parameter type in inflate.c + * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) + * to avoid negation problem on Alphas (64 bit) in inflate.c + * + * 1.2.beta3 22 Dec 2002 + * - Add comments on state->bits assertion in inffast.c + * - Add comments on op field in inftrees.h + * - Fix bug in reuse of allocated window after inflateReset() + * - Remove bit fields--back to byte structure for speed + * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths + * - Change post-increments to pre-increments in inflate_fast(), PPC biased? + * - Add compile time option, POSTINC, to use post-increments instead (Intel?) + * - Make MATCH copy in inflate() much faster for when inflate_fast() not used + * - Use local copies of stream next and avail values, as well as local bit + * buffer and bit count in inflate()--for speed when inflate_fast() not used + * + * 1.2.beta4 1 Jan 2003 + * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings + * - Move a comment on output buffer sizes from inffast.c to inflate.c + * - Add comments in inffast.c to introduce the inflate_fast() routine + * - Rearrange window copies in inflate_fast() for speed and simplification + * - Unroll last copy for window match in inflate_fast() + * - Use local copies of window variables in inflate_fast() for speed + * - Pull out common wnext == 0 case for speed in inflate_fast() + * - Make op and len in inflate_fast() unsigned for consistency + * - Add FAR to lcode and dcode declarations in inflate_fast() + * - Simplified bad distance check in inflate_fast() + * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new + * source file infback.c to provide a call-back interface to inflate for + * programs like gzip and unzip -- uses window as output buffer to avoid + * window copying + * + * 1.2.beta5 1 Jan 2003 + * - Improved inflateBack() interface to allow the caller to provide initial + * input in strm. + * - Fixed stored blocks bug in inflateBack() + * + * 1.2.beta6 4 Jan 2003 + * - Added comments in inffast.c on effectiveness of POSTINC + * - Typecasting all around to reduce compiler warnings + * - Changed loops from while (1) or do {} while (1) to for (;;), again to + * make compilers happy + * - Changed type of window in inflateBackInit() to unsigned char * + * + * 1.2.beta7 27 Jan 2003 + * - Changed many types to unsigned or unsigned short to avoid warnings + * - Added inflateCopy() function + * + * 1.2.0 9 Mar 2003 + * - Changed inflateBack() interface to provide separate opaque descriptors + * for the in() and out() functions + * - Changed inflateBack() argument and in_func typedef to swap the length + * and buffer address return values for the input function + * - Check next_in and next_out for Z_NULL on entry to inflate() + * + * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifdef MAKEFIXED +# ifndef BUILDFIXED +# define BUILDFIXED +# endif +#endif + +/* function prototypes */ +local void fixedtables OF((struct inflate_state FAR *state)); +local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, + unsigned copy)); +#ifdef BUILDFIXED + void makefixed OF((void)); +#endif +local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, + unsigned len)); + +int ZEXPORT inflateResetKeep(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + strm->total_in = strm->total_out = state->total = 0; + strm->msg = Z_NULL; + if (state->wrap) /* to support ill-conceived Java test suite */ + strm->adler = state->wrap & 1; + state->mode = HEAD; + state->last = 0; + state->havedict = 0; + state->dmax = 32768U; + state->head = Z_NULL; + state->hold = 0; + state->bits = 0; + state->lencode = state->distcode = state->next = state->codes; + state->sane = 1; + state->back = -1; + Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +int ZEXPORT inflateReset(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->wsize = 0; + state->whave = 0; + state->wnext = 0; + return inflateResetKeep(strm); +} + +int ZEXPORT inflateReset2(strm, windowBits) +z_streamp strm; +int windowBits; +{ + int wrap; + struct inflate_state FAR *state; + + /* get the state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; +#ifdef GUNZIP + if (windowBits < 48) + windowBits &= 15; +#endif + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) + return Z_STREAM_ERROR; + if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { + ZFREE(strm, state->window); + state->window = Z_NULL; + } + + /* update state and reset the rest of it */ + state->wrap = wrap; + state->wbits = (unsigned)windowBits; + return inflateReset(strm); +} + +int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) +z_streamp strm; +int windowBits; +const char *version; +int stream_size; +{ + int ret; + struct inflate_state FAR *state; + + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != (int)(sizeof(z_stream))) + return Z_VERSION_ERROR; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + state = (struct inflate_state FAR *) + ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + state->window = Z_NULL; + ret = inflateReset2(strm, windowBits); + if (ret != Z_OK) { + ZFREE(strm, state); + strm->state = Z_NULL; + } + return ret; +} + +int ZEXPORT inflateInit_(strm, version, stream_size) +z_streamp strm; +const char *version; +int stream_size; +{ + return inflateInit2_(strm, DEF_WBITS, version, stream_size); +} + +int ZEXPORT inflatePrime(strm, bits, value) +z_streamp strm; +int bits; +int value; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (bits < 0) { + state->hold = 0; + state->bits = 0; + return Z_OK; + } + if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; + state->hold += value << state->bits; + state->bits += bits; + return Z_OK; +} + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +local void fixedtables(state) +struct inflate_state FAR *state; +{ +#ifdef BUILDFIXED + static int virgin = 1; + static code *lenfix, *distfix; + static code fixed[544]; + + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + unsigned sym, bits; + static code *next; + + /* literal/length table */ + sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; + lenfix = next; + bits = 9; + inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); + + /* distance table */ + sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; + bits = 5; + inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); + + /* do this just once */ + virgin = 0; + } +#else /* !BUILDFIXED */ +# include "inffixed.h" +#endif /* BUILDFIXED */ + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + +#ifdef MAKEFIXED +#include + +/* + Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also + defines BUILDFIXED, so the tables are built on the fly. makefixed() writes + those tables to stdout, which would be piped to inffixed.h. A small program + can simply call makefixed to do this: + + void makefixed(void); + + int main(void) + { + makefixed(); + return 0; + } + + Then that can be linked with zlib built with MAKEFIXED defined and run: + + a.out > inffixed.h + */ +void makefixed() +{ + unsigned low, size; + struct inflate_state state; + + fixedtables(&state); + puts(" /* inffixed.h -- table for decoding fixed codes"); + puts(" * Generated automatically by makefixed()."); + puts(" */"); + puts(""); + puts(" /* WARNING: this file should *not* be used by applications."); + puts(" It is part of the implementation of this library and is"); + puts(" subject to change. Applications should only use zlib.h."); + puts(" */"); + puts(""); + size = 1U << 9; + printf(" static const code lenfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 7) == 0) printf("\n "); + printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, + state.lencode[low].bits, state.lencode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); + size = 1U << 5; + printf("\n static const code distfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 6) == 0) printf("\n "); + printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, + state.distcode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); +} +#endif /* MAKEFIXED */ + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +local int updatewindow(strm, end, copy) +z_streamp strm; +const Bytef *end; +unsigned copy; +{ + struct inflate_state FAR *state; + unsigned dist; + + state = (struct inflate_state FAR *)strm->state; + + /* if it hasn't been done already, allocate space for the window */ + if (state->window == Z_NULL) { + state->window = (unsigned char FAR *) + ZALLOC(strm, 1U << state->wbits, + sizeof(unsigned char)); + if (state->window == Z_NULL) return 1; + } + + /* if window not in use yet, initialize */ + if (state->wsize == 0) { + state->wsize = 1U << state->wbits; + state->wnext = 0; + state->whave = 0; + } + + /* copy state->wsize or less output bytes into the circular window */ + if (copy >= state->wsize) { + zmemcpy(state->window, end - state->wsize, state->wsize); + state->wnext = 0; + state->whave = state->wsize; + } + else { + dist = state->wsize - state->wnext; + if (dist > copy) dist = copy; + zmemcpy(state->window + state->wnext, end - copy, dist); + copy -= dist; + if (copy) { + zmemcpy(state->window, end - copy, copy); + state->wnext = copy; + state->whave = state->wsize; + } + else { + state->wnext += dist; + if (state->wnext == state->wsize) state->wnext = 0; + if (state->whave < state->wsize) state->whave += dist; + } + } + return 0; +} + +/* Macros for inflate(): */ + +/* check function to use adler32() for zlib or crc32() for gzip */ +#ifdef GUNZIP +# define UPDATE(check, buf, len) \ + (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) +#else +# define UPDATE(check, buf, len) adler32(check, buf, len) +#endif + +/* check macros for header crc */ +#ifdef GUNZIP +# define CRC2(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + check = crc32(check, hbuf, 2); \ + } while (0) + +# define CRC4(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + hbuf[2] = (unsigned char)((word) >> 16); \ + hbuf[3] = (unsigned char)((word) >> 24); \ + check = crc32(check, hbuf, 4); \ + } while (0) +#endif + +/* Load registers with state in inflate() for speed */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Restore state from registers in inflate() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Get a byte of input into the bit accumulator, or return from inflate() + if there is no input available. */ +#define PULLBYTE() \ + do { \ + if (have == 0) goto inf_leave; \ + have--; \ + hold += (unsigned long)(*next++) << bits; \ + bits += 8; \ + } while (0) + +/* Assure that there are at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflate(). */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + ((unsigned)hold & ((1U << (n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +/* + inflate() uses a state machine to process as much input data and generate as + much output data as possible before returning. The state machine is + structured roughly as follows: + + for (;;) switch (state) { + ... + case STATEn: + if (not enough input data or output space to make progress) + return; + ... make progress ... + state = STATEm; + break; + ... + } + + so when inflate() is called again, the same case is attempted again, and + if the appropriate resources are provided, the machine proceeds to the + next state. The NEEDBITS() macro is usually the way the state evaluates + whether it can proceed or should return. NEEDBITS() does the return if + the requested bits are not available. The typical use of the BITS macros + is: + + NEEDBITS(n); + ... do something with BITS(n) ... + DROPBITS(n); + + where NEEDBITS(n) either returns from inflate() if there isn't enough + input left to load n bits into the accumulator, or it continues. BITS(n) + gives the low n bits in the accumulator. When done, DROPBITS(n) drops + the low n bits off the accumulator. INITBITS() clears the accumulator + and sets the number of available bits to zero. BYTEBITS() discards just + enough bits to put the accumulator on a byte boundary. After BYTEBITS() + and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. + + NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return + if there is no input available. The decoding of variable length codes uses + PULLBYTE() directly in order to pull just enough bytes to decode the next + code, and no more. + + Some states loop until they get enough input, making sure that enough + state information is maintained to continue the loop where it left off + if NEEDBITS() returns in the loop. For example, want, need, and keep + would all have to actually be part of the saved state in case NEEDBITS() + returns: + + case STATEw: + while (want < need) { + NEEDBITS(n); + keep[want++] = BITS(n); + DROPBITS(n); + } + state = STATEx; + case STATEx: + + As shown above, if the next state is also the next case, then the break + is omitted. + + A state may also return if there is not enough output space available to + complete that state. Those states are copying stored data, writing a + literal byte, and copying a matching string. + + When returning, a "goto inf_leave" is used to update the total counters, + update the check value, and determine whether any progress has been made + during that inflate() call in order to return the proper return code. + Progress is defined as a change in either strm->avail_in or strm->avail_out. + When there is a window, goto inf_leave will update the window with the last + output written. If a goto inf_leave occurs in the middle of decompression + and there is no window currently, goto inf_leave will create one and copy + output to the window for the next call of inflate(). + + In this implementation, the flush parameter of inflate() only affects the + return code (per zlib.h). inflate() always writes as much as possible to + strm->next_out, given the space available and the provided input--the effect + documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers + the allocation of and copying into a sliding window until necessary, which + provides the effect documented in zlib.h for Z_FINISH when the entire input + stream available. So the only thing the flush parameter actually does is: + when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it + will return Z_BUF_ERROR if it has not reached the end of the stream. + */ + +int ZEXPORT inflate(strm, flush) +z_streamp strm; +int flush; +{ + struct inflate_state FAR *state; + z_const unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned long hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned in, out; /* save starting available input and output */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char FAR *from; /* where to copy match bytes from */ + code here; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int ret; /* return code */ +#ifdef GUNZIP + unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ +#endif + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0)) + return Z_STREAM_ERROR; + + state = (struct inflate_state FAR *)strm->state; + if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ + LOAD(); + in = have; + out = left; + ret = Z_OK; + for (;;) + switch (state->mode) { + case HEAD: + if (state->wrap == 0) { + state->mode = TYPEDO; + break; + } + NEEDBITS(16); +#ifdef GUNZIP + if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); + state->mode = FLAGS; + break; + } + state->flags = 0; /* expect zlib header */ + if (state->head != Z_NULL) + state->head->done = -1; + if (!(state->wrap & 1) || /* check if zlib header allowed */ +#else + if ( +#endif + ((BITS(8) << 8) + (hold >> 8)) % 31) { + strm->msg = (char *)"incorrect header check"; + state->mode = BAD; + break; + } + if (BITS(4) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + DROPBITS(4); + len = BITS(4) + 8; + if (state->wbits == 0) + state->wbits = len; + else if (len > state->wbits) { + strm->msg = (char *)"invalid window size"; + state->mode = BAD; + break; + } + state->dmax = 1U << len; + Tracev((stderr, "inflate: zlib header ok\n")); + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = hold & 0x200 ? DICTID : TYPE; + INITBITS(); + break; +#ifdef GUNZIP + case FLAGS: + NEEDBITS(16); + state->flags = (int)(hold); + if ((state->flags & 0xff) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + if (state->flags & 0xe000) { + strm->msg = (char *)"unknown header flags set"; + state->mode = BAD; + break; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; + if (state->flags & 0x0200) CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: + NEEDBITS(16); + if (state->head != Z_NULL) { + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: + if (state->flags & 0x0400) { + NEEDBITS(16); + state->length = (unsigned)(hold); + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + } + else if (state->head != Z_NULL) + state->head->extra = Z_NULL; + state->mode = EXTRA; + case EXTRA: + if (state->flags & 0x0400) { + copy = state->length; + if (copy > have) copy = have; + if (copy) { + if (state->head != Z_NULL && + state->head->extra != Z_NULL) { + len = state->head->extra_len - state->length; + zmemcpy(state->head->extra + len, next, + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + state->length -= copy; + } + if (state->length) goto inf_leave; + } + state->length = 0; + state->mode = NAME; + case NAME: + if (state->flags & 0x0800) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) + state->head->name[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->name = Z_NULL; + state->length = 0; + state->mode = COMMENT; + case COMMENT: + if (state->flags & 0x1000) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) + state->head->comment[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->comment = Z_NULL; + state->mode = HCRC; + case HCRC: + if (state->flags & 0x0200) { + NEEDBITS(16); + if (hold != (state->check & 0xffff)) { + strm->msg = (char *)"header crc mismatch"; + state->mode = BAD; + break; + } + INITBITS(); + } + if (state->head != Z_NULL) { + state->head->hcrc = (int)((state->flags >> 9) & 1); + state->head->done = 1; + } + strm->adler = state->check = crc32(0L, Z_NULL, 0); + state->mode = TYPE; + break; +#endif + case DICTID: + NEEDBITS(32); + strm->adler = state->check = ZSWAP32(hold); + INITBITS(); + state->mode = DICT; + case DICT: + if (state->havedict == 0) { + RESTORE(); + return Z_NEED_DICT; + } + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = TYPE; + case TYPE: + if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; + case TYPEDO: + if (state->last) { + BYTEBITS(); + state->mode = CHECK; + break; + } + NEEDBITS(3); + state->last = BITS(1); + DROPBITS(1); + switch (BITS(2)) { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN_; /* decode codes */ + if (flush == Z_TREES) { + DROPBITS(2); + goto inf_leave; + } + break; + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + case 3: + strm->msg = (char *)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); + break; + case STORED: + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { + strm->msg = (char *)"invalid stored block lengths"; + state->mode = BAD; + break; + } + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + state->mode = COPY_; + if (flush == Z_TREES) goto inf_leave; + case COPY_: + state->mode = COPY; + case COPY: + copy = state->length; + if (copy) { + if (copy > have) copy = have; + if (copy > left) copy = left; + if (copy == 0) goto inf_leave; + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + break; + } + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + case TABLE: + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) { + strm->msg = (char *)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; + state->mode = LENLENS; + case LENLENS: + while (state->have < state->ncode) { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (const code FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; + state->mode = CODELENS; + case CODELENS: + while (state->have < state->nlen + state->ndist) { + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.val < 16) { + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } + else { + if (here.val == 16) { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + if (state->have == 0) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + len = state->lens[state->have - 1]; + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + if (state->have + copy > state->nlen + state->ndist) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + while (copy--) + state->lens[state->have++] = (unsigned short)len; + } + } + + /* handle error breaks in while */ + if (state->mode == BAD) break; + + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) { + strm->msg = (char *)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (const code FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (const code FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + if (ret) { + strm->msg = (char *)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN_; + if (flush == Z_TREES) goto inf_leave; + case LEN_: + state->mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + RESTORE(); + inflate_fast(strm, out); + LOAD(); + if (state->mode == TYPE) + state->back = -1; + break; + } + state->back = 0; + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.op && (here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + state->length = (unsigned)here.val; + if ((int)(here.op) == 0) { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + state->mode = LIT; + break; + } + if (here.op & 32) { + Tracevv((stderr, "inflate: end of block\n")); + state->back = -1; + state->mode = TYPE; + break; + } + if (here.op & 64) { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + state->extra = (unsigned)(here.op) & 15; + state->mode = LENEXT; + case LENEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + state->was = state->length; + state->mode = DIST; + case DIST: + for (;;) { + here = state->distcode[BITS(state->distbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if ((here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + if (here.op & 64) { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)here.val; + state->extra = (unsigned)(here.op) & 15; + state->mode = DISTEXT; + case DISTEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } +#ifdef INFLATE_STRICT + if (state->offset > state->dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + state->mode = MATCH; + case MATCH: + if (left == 0) goto inf_leave; + copy = out - left; + if (state->offset > copy) { /* copy from window */ + copy = state->offset - copy; + if (copy > state->whave) { + if (state->sane) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + Trace((stderr, "inflate.c too far\n")); + copy -= state->whave; + if (copy > state->length) copy = state->length; + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = 0; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; +#endif + } + if (copy > state->wnext) { + copy -= state->wnext; + from = state->window + (state->wsize - copy); + } + else + from = state->window + (state->wnext - copy); + if (copy > state->length) copy = state->length; + } + else { /* copy from output */ + from = put - state->offset; + copy = state->length; + } + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = *from++; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; + case LIT: + if (left == 0) goto inf_leave; + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + case CHECK: + if (state->wrap) { + NEEDBITS(32); + out -= left; + strm->total_out += out; + state->total += out; + if (out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + out = left; + if (( +#ifdef GUNZIP + state->flags ? hold : +#endif + ZSWAP32(hold)) != state->check) { + strm->msg = (char *)"incorrect data check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: check matches trailer\n")); + } +#ifdef GUNZIP + state->mode = LENGTH; + case LENGTH: + if (state->wrap && state->flags) { + NEEDBITS(32); + if (hold != (state->total & 0xffffffffUL)) { + strm->msg = (char *)"incorrect length check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: length matches trailer\n")); + } +#endif + state->mode = DONE; + case DONE: + ret = Z_STREAM_END; + goto inf_leave; + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + inf_leave: + RESTORE(); + if (state->wsize || (out != strm->avail_out && state->mode < BAD && + (state->mode < CHECK || flush != Z_FINISH))) + if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } + in -= strm->avail_in; + out -= strm->avail_out; + strm->total_in += in; + strm->total_out += out; + state->total += out; + if (state->wrap && out) + strm->adler = state->check = + UPDATE(state->check, strm->next_out - out, out); + strm->data_type = state->bits + (state->last ? 64 : 0) + + (state->mode == TYPE ? 128 : 0) + + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) + ret = Z_BUF_ERROR; + return ret; +} + +int ZEXPORT inflateEnd(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); + ZFREE(strm, strm->state); + strm->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} + +int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) +z_streamp strm; +Bytef *dictionary; +uInt *dictLength; +{ + struct inflate_state FAR *state; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* copy dictionary */ + if (state->whave && dictionary != Z_NULL) { + zmemcpy(dictionary, state->window + state->wnext, + state->whave - state->wnext); + zmemcpy(dictionary + state->whave - state->wnext, + state->window, state->wnext); + } + if (dictLength != Z_NULL) + *dictLength = state->whave; + return Z_OK; +} + +int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) +z_streamp strm; +const Bytef *dictionary; +uInt dictLength; +{ + struct inflate_state FAR *state; + unsigned long dictid; + int ret; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->wrap != 0 && state->mode != DICT) + return Z_STREAM_ERROR; + + /* check for correct dictionary identifier */ + if (state->mode == DICT) { + dictid = adler32(0L, Z_NULL, 0); + dictid = adler32(dictid, dictionary, dictLength); + if (dictid != state->check) + return Z_DATA_ERROR; + } + + /* copy dictionary to window using updatewindow(), which will amend the + existing dictionary if appropriate */ + ret = updatewindow(strm, dictionary + dictLength, dictLength); + if (ret) { + state->mode = MEM; + return Z_MEM_ERROR; + } + state->havedict = 1; + Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +int ZEXPORT inflateGetHeader(strm, head) +z_streamp strm; +gz_headerp head; +{ + struct inflate_state FAR *state; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; + + /* save header structure */ + state->head = head; + head->done = 0; + return Z_OK; +} + +/* + Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found + or when out of input. When called, *have is the number of pattern bytes + found in order so far, in 0..3. On return *have is updated to the new + state. If on return *have equals four, then the pattern was found and the + return value is how many bytes were read including the last byte of the + pattern. If *have is less than four, then the pattern has not been found + yet and the return value is len. In the latter case, syncsearch() can be + called again with more data and the *have state. *have is initialized to + zero for the first call. + */ +local unsigned syncsearch(have, buf, len) +unsigned FAR *have; +const unsigned char FAR *buf; +unsigned len; +{ + unsigned got; + unsigned next; + + got = *have; + next = 0; + while (next < len && got < 4) { + if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) + got++; + else if (buf[next]) + got = 0; + else + got = 4 - got; + next++; + } + *have = got; + return next; +} + +int ZEXPORT inflateSync(strm) +z_streamp strm; +{ + unsigned len; /* number of bytes to look at or looked at */ + unsigned long in, out; /* temporary to save total_in and total_out */ + unsigned char buf[4]; /* to restore bit buffer to byte string */ + struct inflate_state FAR *state; + + /* check parameters */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; + + /* if first time, start search in bit buffer */ + if (state->mode != SYNC) { + state->mode = SYNC; + state->hold <<= state->bits & 7; + state->bits -= state->bits & 7; + len = 0; + while (state->bits >= 8) { + buf[len++] = (unsigned char)(state->hold); + state->hold >>= 8; + state->bits -= 8; + } + state->have = 0; + syncsearch(&(state->have), buf, len); + } + + /* search available input */ + len = syncsearch(&(state->have), strm->next_in, strm->avail_in); + strm->avail_in -= len; + strm->next_in += len; + strm->total_in += len; + + /* return no joy or set up to restart inflate() on a new block */ + if (state->have != 4) return Z_DATA_ERROR; + in = strm->total_in; out = strm->total_out; + inflateReset(strm); + strm->total_in = in; strm->total_out = out; + state->mode = TYPE; + return Z_OK; +} + +/* + Returns true if inflate is currently at the end of a block generated by + Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + implementation to provide an additional safety check. PPP uses + Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored + block. When decompressing, PPP checks that at the end of input packet, + inflate is waiting for these length bytes. + */ +int ZEXPORT inflateSyncPoint(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + return state->mode == STORED && state->bits == 0; +} + +int ZEXPORT inflateCopy(dest, source) +z_streamp dest; +z_streamp source; +{ + struct inflate_state FAR *state; + struct inflate_state FAR *copy; + unsigned char FAR *window; + unsigned wsize; + + /* check input */ + if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || + source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)source->state; + + /* allocate space */ + copy = (struct inflate_state FAR *) + ZALLOC(source, 1, sizeof(struct inflate_state)); + if (copy == Z_NULL) return Z_MEM_ERROR; + window = Z_NULL; + if (state->window != Z_NULL) { + window = (unsigned char FAR *) + ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); + if (window == Z_NULL) { + ZFREE(source, copy); + return Z_MEM_ERROR; + } + } + + /* copy state */ + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); + if (state->lencode >= state->codes && + state->lencode <= state->codes + ENOUGH - 1) { + copy->lencode = copy->codes + (state->lencode - state->codes); + copy->distcode = copy->codes + (state->distcode - state->codes); + } + copy->next = copy->codes + (state->next - state->codes); + if (window != Z_NULL) { + wsize = 1U << state->wbits; + zmemcpy(window, state->window, wsize); + } + copy->window = window; + dest->state = (struct internal_state FAR *)copy; + return Z_OK; +} + +int ZEXPORT inflateUndermine(strm, subvert) +z_streamp strm; +int subvert; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->sane = !subvert; +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + return Z_OK; +#else + state->sane = 1; + return Z_DATA_ERROR; +#endif +} + +long ZEXPORT inflateMark(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; + state = (struct inflate_state FAR *)strm->state; + return ((long)(state->back) << 16) + + (state->mode == COPY ? state->length : + (state->mode == MATCH ? state->was - state->length : 0)); +} diff --git a/zlib/src/inflate.h b/zlib/src/inflate.h new file mode 100644 index 0000000..95f4986 --- /dev/null +++ b/zlib/src/inflate.h @@ -0,0 +1,122 @@ +/* inflate.h -- internal inflate state definition + * Copyright (C) 1995-2009 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer decoding by inflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip decoding + should be left enabled. */ +#ifndef NO_GZIP +# define GUNZIP +#endif + +/* Possible inflate modes between inflate() calls */ +typedef enum { + HEAD, /* i: waiting for magic header */ + FLAGS, /* i: waiting for method and flags (gzip) */ + TIME, /* i: waiting for modification time (gzip) */ + OS, /* i: waiting for extra flags and operating system (gzip) */ + EXLEN, /* i: waiting for extra length (gzip) */ + EXTRA, /* i: waiting for extra bytes (gzip) */ + NAME, /* i: waiting for end of file name (gzip) */ + COMMENT, /* i: waiting for end of comment (gzip) */ + HCRC, /* i: waiting for header crc (gzip) */ + DICTID, /* i: waiting for dictionary check value */ + DICT, /* waiting for inflateSetDictionary() call */ + TYPE, /* i: waiting for type bits, including last-flag bit */ + TYPEDO, /* i: same, but skip check to exit inflate on new block */ + STORED, /* i: waiting for stored size (length and complement) */ + COPY_, /* i/o: same as COPY below, but only first time in */ + COPY, /* i/o: waiting for input or output to copy stored block */ + TABLE, /* i: waiting for dynamic block table lengths */ + LENLENS, /* i: waiting for code length code lengths */ + CODELENS, /* i: waiting for length/lit and distance code lengths */ + LEN_, /* i: same as LEN below, but only first time in */ + LEN, /* i: waiting for length/lit/eob code */ + LENEXT, /* i: waiting for length extra bits */ + DIST, /* i: waiting for distance code */ + DISTEXT, /* i: waiting for distance extra bits */ + MATCH, /* o: waiting for output space to copy string */ + LIT, /* o: waiting for output space to write literal */ + CHECK, /* i: waiting for 32-bit check value */ + LENGTH, /* i: waiting for 32-bit length (gzip) */ + DONE, /* finished check, done -- remain here until reset */ + BAD, /* got a data error -- remain here until reset */ + MEM, /* got an inflate() memory error -- remain here until reset */ + SYNC /* looking for synchronization bytes to restart inflate() */ +} inflate_mode; + +/* + State transitions between above modes - + + (most modes can go to BAD or MEM on error -- not shown for clarity) + + Process header: + HEAD -> (gzip) or (zlib) or (raw) + (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> + HCRC -> TYPE + (zlib) -> DICTID or TYPE + DICTID -> DICT -> TYPE + (raw) -> TYPEDO + Read deflate blocks: + TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK + STORED -> COPY_ -> COPY -> TYPE + TABLE -> LENLENS -> CODELENS -> LEN_ + LEN_ -> LEN + Read deflate codes in fixed or dynamic block: + LEN -> LENEXT or LIT or TYPE + LENEXT -> DIST -> DISTEXT -> MATCH -> LEN + LIT -> LEN + Process trailer: + CHECK -> LENGTH -> DONE + */ + +/* state maintained between inflate() calls. Approximately 10K bytes. */ +struct inflate_state { + inflate_mode mode; /* current inflate mode */ + int last; /* true if processing last block */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + int havedict; /* true if dictionary provided */ + int flags; /* gzip header method and flags (0 if zlib) */ + unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ + unsigned long check; /* protected copy of check value */ + unsigned long total; /* protected copy of output count */ + gz_headerp head; /* where to save gzip header information */ + /* sliding window */ + unsigned wbits; /* log base 2 of requested window size */ + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if needed */ + /* bit accumulator */ + unsigned long hold; /* input bit accumulator */ + unsigned bits; /* number of bits in "in" */ + /* for string and stored block copying */ + unsigned length; /* literal or length of data to copy */ + unsigned offset; /* distance back to copy string from */ + /* for table and code decoding */ + unsigned extra; /* extra bits needed */ + /* fixed and dynamic code tables */ + code const FAR *lencode; /* starting table for length/literal codes */ + code const FAR *distcode; /* starting table for distance codes */ + unsigned lenbits; /* index bits for lencode */ + unsigned distbits; /* index bits for distcode */ + /* dynamic table building */ + unsigned ncode; /* number of code length code lengths */ + unsigned nlen; /* number of length code lengths */ + unsigned ndist; /* number of distance code lengths */ + unsigned have; /* number of code lengths in lens[] */ + code FAR *next; /* next available space in codes[] */ + unsigned short lens[320]; /* temporary storage for code lengths */ + unsigned short work[288]; /* work area for code table building */ + code codes[ENOUGH]; /* space for code tables */ + int sane; /* if false, allow invalid distance too far */ + int back; /* bits back of last unprocessed length/lit */ + unsigned was; /* initial length of match */ +}; diff --git a/zlib/src/inftrees.c b/zlib/src/inftrees.c new file mode 100644 index 0000000..44d89cf --- /dev/null +++ b/zlib/src/inftrees.c @@ -0,0 +1,306 @@ +/* inftrees.c -- generate Huffman trees for efficient decoding + * Copyright (C) 1995-2013 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" + +#define MAXBITS 15 + +const char inflate_copyright[] = + " inflate 1.2.8 Copyright 1995-2013 Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* + Build a set of tables to decode the provided canonical Huffman code. + The code lengths are lens[0..codes-1]. The result starts at *table, + whose indices are 0..2^bits-1. work is a writable array of at least + lens shorts, which is used as a work area. type is the type of code + to be generated, CODES, LENS, or DISTS. On return, zero is success, + -1 is an invalid code, and +1 means that ENOUGH isn't enough. table + on return points to the next available entry's address. bits is the + requested root table index bits, and on return it is the actual root + table index bits. It will differ if the request is greater than the + longest code or if it is less than the shortest code. + */ +int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) +codetype type; +unsigned short FAR *lens; +unsigned codes; +code FAR * FAR *table; +unsigned FAR *bits; +unsigned short FAR *work; +{ + unsigned len; /* a code's length in bits */ + unsigned sym; /* index of code symbols */ + unsigned min, max; /* minimum and maximum code lengths */ + unsigned root; /* number of index bits for root table */ + unsigned curr; /* number of index bits for current table */ + unsigned drop; /* code bits to drop for sub-table */ + int left; /* number of prefix codes available */ + unsigned used; /* code entries in table used */ + unsigned huff; /* Huffman code */ + unsigned incr; /* for incrementing code, index */ + unsigned fill; /* index for replicating entries */ + unsigned low; /* low bits for current root entry */ + unsigned mask; /* mask for low root bits */ + code here; /* table entry for duplication */ + code FAR *next; /* next available space in table */ + const unsigned short FAR *base; /* base value table to use */ + const unsigned short FAR *extra; /* extra bits table to use */ + int end; /* use base and extra for symbol > end */ + unsigned short count[MAXBITS+1]; /* number of codes of each length */ + unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = { /* Length codes 257..285 base */ + 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 unsigned short lext[31] = { /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78}; + static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 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 unsigned short dext[32] = { /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64}; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) + count[len] = 0; + for (sym = 0; sym < codes; sym++) + count[lens[sym]]++; + + /* bound code lengths, force root to be within code lengths */ + root = *bits; + for (max = MAXBITS; max >= 1; max--) + if (count[max] != 0) break; + if (root > max) root = max; + if (max == 0) { /* no symbols to code at all */ + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)1; + here.val = (unsigned short)0; + *(*table)++ = here; /* make a table to force an error */ + *(*table)++ = here; + *bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) + if (count[min] != 0) break; + if (root < min) root = min; + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) return -1; /* over-subscribed */ + } + if (left > 0 && (type == CODES || max != 1)) + return -1; /* incomplete set */ + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + offs[len + 1] = offs[len] + count[len]; + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) + if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + switch (type) { + case CODES: + base = extra = work; /* dummy value--not used */ + end = 19; + break; + case LENS: + base = lbase; + base -= 257; + extra = lext; + extra -= 257; + end = 256; + break; + default: /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize state for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = *table; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = (unsigned)(-1); /* trigger new sub-table when len > root */ + used = 1U << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type == LENS && used > ENOUGH_LENS) || + (type == DISTS && used > ENOUGH_DISTS)) + return 1; + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here.bits = (unsigned char)(len - drop); + if ((int)(work[sym]) < end) { + here.op = (unsigned char)0; + here.val = work[sym]; + } + else if ((int)(work[sym]) > end) { + here.op = (unsigned char)(extra[work[sym]]); + here.val = base[work[sym]]; + } + else { + here.op = (unsigned char)(32 + 64); /* end of block */ + here.val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1U << (len - drop); + fill = 1U << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + next[(huff >> drop) + fill] = here; + } while (fill != 0); + + /* backwards increment the len-bit code huff */ + incr = 1U << (len - 1); + while (huff & incr) + incr >>= 1; + if (incr != 0) { + huff &= incr - 1; + huff += incr; + } + else + huff = 0; + + /* go to next symbol, update count, len */ + sym++; + if (--(count[len]) == 0) { + if (len == max) break; + len = lens[work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) != low) { + /* if first time, transition to sub-tables */ + if (drop == 0) + drop = root; + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = (int)(1 << curr); + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) break; + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1U << curr; + if ((type == LENS && used > ENOUGH_LENS) || + (type == DISTS && used > ENOUGH_DISTS)) + return 1; + + /* point entry in root table to sub-table */ + low = huff & mask; + (*table)[low].op = (unsigned char)curr; + (*table)[low].bits = (unsigned char)root; + (*table)[low].val = (unsigned short)(next - *table); + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff != 0) { + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)(len - drop); + here.val = (unsigned short)0; + next[huff] = here; + } + + /* set return parameters */ + *table += used; + *bits = root; + return 0; +} diff --git a/zlib/src/inftrees.h b/zlib/src/inftrees.h new file mode 100644 index 0000000..baa53a0 --- /dev/null +++ b/zlib/src/inftrees.h @@ -0,0 +1,62 @@ +/* inftrees.h -- header to use inftrees.c + * Copyright (C) 1995-2005, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* Structure for decoding tables. Each entry provides either the + information needed to do the operation requested by the code that + indexed that table entry, or it provides a pointer to another + table that indexes more bits of the code. op indicates whether + the entry is a pointer to another table, a literal, a length or + distance, an end-of-block, or an invalid code. For a table + pointer, the low four bits of op is the number of index bits of + that table. For a length or distance, the low four bits of op + is the number of extra bits to get after the code. bits is + the number of bits in this code or part of the code to drop off + of the bit buffer. val is the actual byte to output in the case + of a literal, the base length or distance, or the offset from + the current table to the next table. Each entry is four bytes. */ +typedef struct { + unsigned char op; /* operation, extra bits, table bits */ + unsigned char bits; /* bits in this part of the code */ + unsigned short val; /* offset in table or code value */ +} code; + +/* op values as set by inflate_table(): + 00000000 - literal + 0000tttt - table link, tttt != 0 is the number of table index bits + 0001eeee - length or distance, eeee is the number of extra bits + 01100000 - end of block + 01000000 - invalid code + */ + +/* Maximum size of the dynamic table. The maximum number of code structures is + 1444, which is the sum of 852 for literal/length codes and 592 for distance + codes. These values were found by exhaustive searches using the program + examples/enough.c found in the zlib distribtution. The arguments to that + program are the number of symbols, the initial root table size, and the + maximum bit length of a code. "enough 286 9 15" for literal/length codes + returns returns 852, and "enough 30 6 15" for distance codes returns 592. + The initial root table size (9 or 6) is found in the fifth argument of the + inflate_table() calls in inflate.c and infback.c. If the root table size is + changed, then these maximum sizes would be need to be recalculated and + updated. */ +#define ENOUGH_LENS 852 +#define ENOUGH_DISTS 592 +#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) + +/* Type of code to build for inflate_table() */ +typedef enum { + CODES, + LENS, + DISTS +} codetype; + +int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, + unsigned codes, code FAR * FAR *table, + unsigned FAR *bits, unsigned short FAR *work)); diff --git a/zlib/src/make_vms.com b/zlib/src/make_vms.com new file mode 100644 index 0000000..65e9d0c --- /dev/null +++ b/zlib/src/make_vms.com @@ -0,0 +1,867 @@ +$! make libz under VMS written by +$! Martin P.J. Zinser +$! +$! In case of problems with the install you might contact me at +$! zinser@zinser.no-ip.info(preferred) or +$! martin.zinser@eurexchange.com (work) +$! +$! Make procedure history for Zlib +$! +$!------------------------------------------------------------------------------ +$! Version history +$! 0.01 20060120 First version to receive a number +$! 0.02 20061008 Adapt to new Makefile.in +$! 0.03 20091224 Add support for large file check +$! 0.04 20100110 Add new gzclose, gzlib, gzread, gzwrite +$! 0.05 20100221 Exchange zlibdefs.h by zconf.h.in +$! 0.06 20120111 Fix missing amiss_err, update zconf_h.in, fix new exmples +$! subdir path, update module search in makefile.in +$! 0.07 20120115 Triggered by work done by Alexey Chupahin completly redesigned +$! shared image creation +$! 0.08 20120219 Make it work on VAX again, pre-load missing symbols to shared +$! image +$! 0.09 20120305 SMS. P1 sets builder ("MMK", "MMS", " " (built-in)). +$! "" -> automatic, preference: MMK, MMS, built-in. +$! +$ on error then goto err_exit +$! +$ true = 1 +$ false = 0 +$ tmpnam = "temp_" + f$getjpi("","pid") +$ tt = tmpnam + ".txt" +$ tc = tmpnam + ".c" +$ th = tmpnam + ".h" +$ define/nolog tconfig 'th' +$ its_decc = false +$ its_vaxc = false +$ its_gnuc = false +$ s_case = False +$! +$! Setup variables holding "config" information +$! +$ Make = "''p1'" +$ name = "Zlib" +$ version = "?.?.?" +$ v_string = "ZLIB_VERSION" +$ v_file = "zlib.h" +$ ccopt = "/include = []" +$ lopts = "" +$ dnsrl = "" +$ aconf_in_file = "zconf.h.in#zconf.h_in#zconf_h.in" +$ conf_check_string = "" +$ linkonly = false +$ optfile = name + ".opt" +$ mapfile = name + ".map" +$ libdefs = "" +$ vax = f$getsyi("HW_MODEL").lt.1024 +$ axp = f$getsyi("HW_MODEL").ge.1024 .and. f$getsyi("HW_MODEL").lt.4096 +$ ia64 = f$getsyi("HW_MODEL").ge.4096 +$! +$! 2012-03-05 SMS. +$! Why is this needed? And if it is needed, why not simply ".not. vax"? +$! +$!!! if axp .or. ia64 then set proc/parse=extended +$! +$ whoami = f$parse(f$environment("Procedure"),,,,"NO_CONCEAL") +$ mydef = F$parse(whoami,,,"DEVICE") +$ mydir = f$parse(whoami,,,"DIRECTORY") - "][" +$ myproc = f$parse(whoami,,,"Name") + f$parse(whoami,,,"type") +$! +$! Check for MMK/MMS +$! +$ if (Make .eqs. "") +$ then +$ If F$Search ("Sys$System:MMS.EXE") .nes. "" Then Make = "MMS" +$ If F$Type (MMK) .eqs. "STRING" Then Make = "MMK" +$ else +$ Make = f$edit( Make, "trim") +$ endif +$! +$ gosub find_version +$! +$ open/write topt tmp.opt +$ open/write optf 'optfile' +$! +$ gosub check_opts +$! +$! Look for the compiler used +$! +$ gosub check_compiler +$ close topt +$ close optf +$! +$ if its_decc +$ then +$ ccopt = "/prefix=all" + ccopt +$ if f$trnlnm("SYS") .eqs. "" +$ then +$ if axp +$ then +$ define sys sys$library: +$ else +$ ccopt = "/decc" + ccopt +$ define sys decc$library_include: +$ endif +$ endif +$! +$! 2012-03-05 SMS. +$! Why /NAMES = AS_IS? Why not simply ".not. vax"? And why not on VAX? +$! +$ if axp .or. ia64 +$ then +$ ccopt = ccopt + "/name=as_is/opt=(inline=speed)" +$ s_case = true +$ endif +$ endif +$ if its_vaxc .or. its_gnuc +$ then +$ if f$trnlnm("SYS").eqs."" then define sys sys$library: +$ endif +$! +$! Build a fake configure input header +$! +$ open/write conf_hin config.hin +$ write conf_hin "#undef _LARGEFILE64_SOURCE" +$ close conf_hin +$! +$! +$ i = 0 +$FIND_ACONF: +$ fname = f$element(i,"#",aconf_in_file) +$ if fname .eqs. "#" then goto AMISS_ERR +$ if f$search(fname) .eqs. "" +$ then +$ i = i + 1 +$ goto find_aconf +$ endif +$ open/read/err=aconf_err aconf_in 'fname' +$ open/write aconf zconf.h +$ACONF_LOOP: +$ read/end_of_file=aconf_exit aconf_in line +$ work = f$edit(line, "compress,trim") +$ if f$extract(0,6,work) .nes. "#undef" +$ then +$ if f$extract(0,12,work) .nes. "#cmakedefine" +$ then +$ write aconf line +$ endif +$ else +$ cdef = f$element(1," ",work) +$ gosub check_config +$ endif +$ goto aconf_loop +$ACONF_EXIT: +$ write aconf "" +$ write aconf "/* VMS specifics added by make_vms.com: */" +$ write aconf "#define VMS 1" +$ write aconf "#include " +$ write aconf "#include " +$ write aconf "#ifdef _LARGEFILE" +$ write aconf "# define off64_t __off64_t" +$ write aconf "# define fopen64 fopen" +$ write aconf "# define fseeko64 fseeko" +$ write aconf "# define lseek64 lseek" +$ write aconf "# define ftello64 ftell" +$ write aconf "#endif" +$ write aconf "#if !defined( __VAX) && (__CRTL_VER >= 70312000)" +$ write aconf "# define HAVE_VSNPRINTF" +$ write aconf "#endif" +$ close aconf_in +$ close aconf +$ if f$search("''th'") .nes. "" then delete 'th';* +$! Build the thing plain or with mms +$! +$ write sys$output "Compiling Zlib sources ..." +$ if make.eqs."" +$ then +$ if (f$search( "example.obj;*") .nes. "") then delete example.obj;* +$ if (f$search( "minigzip.obj;*") .nes. "") then delete minigzip.obj;* +$ CALL MAKE adler32.OBJ "CC ''CCOPT' adler32" - + adler32.c zlib.h zconf.h +$ CALL MAKE compress.OBJ "CC ''CCOPT' compress" - + compress.c zlib.h zconf.h +$ CALL MAKE crc32.OBJ "CC ''CCOPT' crc32" - + crc32.c zlib.h zconf.h +$ CALL MAKE deflate.OBJ "CC ''CCOPT' deflate" - + deflate.c deflate.h zutil.h zlib.h zconf.h +$ CALL MAKE gzclose.OBJ "CC ''CCOPT' gzclose" - + gzclose.c zutil.h zlib.h zconf.h +$ CALL MAKE gzlib.OBJ "CC ''CCOPT' gzlib" - + gzlib.c zutil.h zlib.h zconf.h +$ CALL MAKE gzread.OBJ "CC ''CCOPT' gzread" - + gzread.c zutil.h zlib.h zconf.h +$ CALL MAKE gzwrite.OBJ "CC ''CCOPT' gzwrite" - + gzwrite.c zutil.h zlib.h zconf.h +$ CALL MAKE infback.OBJ "CC ''CCOPT' infback" - + infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h +$ CALL MAKE inffast.OBJ "CC ''CCOPT' inffast" - + inffast.c zutil.h zlib.h zconf.h inffast.h +$ CALL MAKE inflate.OBJ "CC ''CCOPT' inflate" - + inflate.c zutil.h zlib.h zconf.h infblock.h +$ CALL MAKE inftrees.OBJ "CC ''CCOPT' inftrees" - + inftrees.c zutil.h zlib.h zconf.h inftrees.h +$ CALL MAKE trees.OBJ "CC ''CCOPT' trees" - + trees.c deflate.h zutil.h zlib.h zconf.h +$ CALL MAKE uncompr.OBJ "CC ''CCOPT' uncompr" - + uncompr.c zlib.h zconf.h +$ CALL MAKE zutil.OBJ "CC ''CCOPT' zutil" - + zutil.c zutil.h zlib.h zconf.h +$ write sys$output "Building Zlib ..." +$ CALL MAKE libz.OLB "lib/crea libz.olb *.obj" *.OBJ +$ write sys$output "Building example..." +$ CALL MAKE example.OBJ "CC ''CCOPT' [.test]example" - + [.test]example.c zlib.h zconf.h +$ call make example.exe "LINK example,libz.olb/lib" example.obj libz.olb +$ write sys$output "Building minigzip..." +$ CALL MAKE minigzip.OBJ "CC ''CCOPT' [.test]minigzip" - + [.test]minigzip.c zlib.h zconf.h +$ call make minigzip.exe - + "LINK minigzip,libz.olb/lib" - + minigzip.obj libz.olb +$ else +$ gosub crea_mms +$ write sys$output "Make ''name' ''version' with ''Make' " +$ 'make' +$ endif +$! +$! Create shareable image +$! +$ gosub crea_olist +$ write sys$output "Creating libzshr.exe" +$ call map_2_shopt 'mapfile' 'optfile' +$ LINK_'lopts'/SHARE=libzshr.exe modules.opt/opt,'optfile'/opt +$ write sys$output "Zlib build completed" +$ delete/nolog tmp.opt;* +$ exit +$AMISS_ERR: +$ write sys$output "No source for config.hin found." +$ write sys$output "Tried any of ''aconf_in_file'" +$ goto err_exit +$CC_ERR: +$ write sys$output "C compiler required to build ''name'" +$ goto err_exit +$ERR_EXIT: +$ set message/facil/ident/sever/text +$ close/nolog optf +$ close/nolog topt +$ close/nolog aconf_in +$ close/nolog aconf +$ close/nolog out +$ close/nolog min +$ close/nolog mod +$ close/nolog h_in +$ write sys$output "Exiting..." +$ exit 2 +$! +$! +$MAKE: SUBROUTINE !SUBROUTINE TO CHECK DEPENDENCIES +$ V = 'F$Verify(0) +$! P1 = What we are trying to make +$! P2 = Command to make it +$! P3 - P8 What it depends on +$ +$ If F$Search(P1) .Eqs. "" Then Goto Makeit +$ Time = F$CvTime(F$File(P1,"RDT")) +$arg=3 +$Loop: +$ Argument = P'arg +$ If Argument .Eqs. "" Then Goto Exit +$ El=0 +$Loop2: +$ File = F$Element(El," ",Argument) +$ If File .Eqs. " " Then Goto Endl +$ AFile = "" +$Loop3: +$ OFile = AFile +$ AFile = F$Search(File) +$ If AFile .Eqs. "" .Or. AFile .Eqs. OFile Then Goto NextEl +$ If F$CvTime(F$File(AFile,"RDT")) .Ges. Time Then Goto Makeit +$ Goto Loop3 +$NextEL: +$ El = El + 1 +$ Goto Loop2 +$EndL: +$ arg=arg+1 +$ If arg .Le. 8 Then Goto Loop +$ Goto Exit +$ +$Makeit: +$ VV=F$VERIFY(0) +$ write sys$output P2 +$ 'P2 +$ VV='F$Verify(VV) +$Exit: +$ If V Then Set Verify +$ENDSUBROUTINE +$!------------------------------------------------------------------------------ +$! +$! Check command line options and set symbols accordingly +$! +$!------------------------------------------------------------------------------ +$! Version history +$! 0.01 20041206 First version to receive a number +$! 0.02 20060126 Add new "HELP" target +$ CHECK_OPTS: +$ i = 1 +$ OPT_LOOP: +$ if i .lt. 9 +$ then +$ cparm = f$edit(p'i',"upcase") +$! +$! Check if parameter actually contains something +$! +$ if f$edit(cparm,"trim") .nes. "" +$ then +$ if cparm .eqs. "DEBUG" +$ then +$ ccopt = ccopt + "/noopt/deb" +$ lopts = lopts + "/deb" +$ endif +$ if f$locate("CCOPT=",cparm) .lt. f$length(cparm) +$ then +$ start = f$locate("=",cparm) + 1 +$ len = f$length(cparm) - start +$ ccopt = ccopt + f$extract(start,len,cparm) +$ if f$locate("AS_IS",f$edit(ccopt,"UPCASE")) .lt. f$length(ccopt) - + then s_case = true +$ endif +$ if cparm .eqs. "LINK" then linkonly = true +$ if f$locate("LOPTS=",cparm) .lt. f$length(cparm) +$ then +$ start = f$locate("=",cparm) + 1 +$ len = f$length(cparm) - start +$ lopts = lopts + f$extract(start,len,cparm) +$ endif +$ if f$locate("CC=",cparm) .lt. f$length(cparm) +$ then +$ start = f$locate("=",cparm) + 1 +$ len = f$length(cparm) - start +$ cc_com = f$extract(start,len,cparm) + if (cc_com .nes. "DECC") .and. - + (cc_com .nes. "VAXC") .and. - + (cc_com .nes. "GNUC") +$ then +$ write sys$output "Unsupported compiler choice ''cc_com' ignored" +$ write sys$output "Use DECC, VAXC, or GNUC instead" +$ else +$ if cc_com .eqs. "DECC" then its_decc = true +$ if cc_com .eqs. "VAXC" then its_vaxc = true +$ if cc_com .eqs. "GNUC" then its_gnuc = true +$ endif +$ endif +$ if f$locate("MAKE=",cparm) .lt. f$length(cparm) +$ then +$ start = f$locate("=",cparm) + 1 +$ len = f$length(cparm) - start +$ mmks = f$extract(start,len,cparm) +$ if (mmks .eqs. "MMK") .or. (mmks .eqs. "MMS") +$ then +$ make = mmks +$ else +$ write sys$output "Unsupported make choice ''mmks' ignored" +$ write sys$output "Use MMK or MMS instead" +$ endif +$ endif +$ if cparm .eqs. "HELP" then gosub bhelp +$ endif +$ i = i + 1 +$ goto opt_loop +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! Look for the compiler used +$! +$! Version history +$! 0.01 20040223 First version to receive a number +$! 0.02 20040229 Save/set value of decc$no_rooted_search_lists +$! 0.03 20060202 Extend handling of GNU C +$! 0.04 20090402 Compaq -> hp +$CHECK_COMPILER: +$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc)) +$ then +$ its_decc = (f$search("SYS$SYSTEM:DECC$COMPILER.EXE") .nes. "") +$ its_vaxc = .not. its_decc .and. (F$Search("SYS$System:VAXC.Exe") .nes. "") +$ its_gnuc = .not. (its_decc .or. its_vaxc) .and. (f$trnlnm("gnu_cc") .nes. "") +$ endif +$! +$! Exit if no compiler available +$! +$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc)) +$ then goto CC_ERR +$ else +$ if its_decc +$ then +$ write sys$output "CC compiler check ... hp C" +$ if f$trnlnm("decc$no_rooted_search_lists") .nes. "" +$ then +$ dnrsl = f$trnlnm("decc$no_rooted_search_lists") +$ endif +$ define/nolog decc$no_rooted_search_lists 1 +$ else +$ if its_vaxc then write sys$output "CC compiler check ... VAX C" +$ if its_gnuc +$ then +$ write sys$output "CC compiler check ... GNU C" +$ if f$trnlnm(topt) then write topt "gnu_cc:[000000]gcclib.olb/lib" +$ if f$trnlnm(optf) then write optf "gnu_cc:[000000]gcclib.olb/lib" +$ cc = "gcc" +$ endif +$ if f$trnlnm(topt) then write topt "sys$share:vaxcrtl.exe/share" +$ if f$trnlnm(optf) then write optf "sys$share:vaxcrtl.exe/share" +$ endif +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! If MMS/MMK are available dump out the descrip.mms if required +$! +$CREA_MMS: +$ write sys$output "Creating descrip.mms..." +$ create descrip.mms +$ open/append out descrip.mms +$ copy sys$input: out +$ deck +# descrip.mms: MMS description file for building zlib on VMS +# written by Martin P.J. Zinser +# + +OBJS = adler32.obj, compress.obj, crc32.obj, gzclose.obj, gzlib.obj\ + gzread.obj, gzwrite.obj, uncompr.obj, infback.obj\ + deflate.obj, trees.obj, zutil.obj, inflate.obj, \ + inftrees.obj, inffast.obj + +$ eod +$ write out "CFLAGS=", ccopt +$ write out "LOPTS=", lopts +$ write out "all : example.exe minigzip.exe libz.olb" +$ copy sys$input: out +$ deck + @ write sys$output " Example applications available" + +libz.olb : libz.olb($(OBJS)) + @ write sys$output " libz available" + +example.exe : example.obj libz.olb + link $(LOPTS) example,libz.olb/lib + +minigzip.exe : minigzip.obj libz.olb + link $(LOPTS) minigzip,libz.olb/lib + +clean : + delete *.obj;*,libz.olb;*,*.opt;*,*.exe;* + + +# Other dependencies. +adler32.obj : adler32.c zutil.h zlib.h zconf.h +compress.obj : compress.c zlib.h zconf.h +crc32.obj : crc32.c zutil.h zlib.h zconf.h +deflate.obj : deflate.c deflate.h zutil.h zlib.h zconf.h +example.obj : [.test]example.c zlib.h zconf.h +gzclose.obj : gzclose.c zutil.h zlib.h zconf.h +gzlib.obj : gzlib.c zutil.h zlib.h zconf.h +gzread.obj : gzread.c zutil.h zlib.h zconf.h +gzwrite.obj : gzwrite.c zutil.h zlib.h zconf.h +inffast.obj : inffast.c zutil.h zlib.h zconf.h inftrees.h inffast.h +inflate.obj : inflate.c zutil.h zlib.h zconf.h +inftrees.obj : inftrees.c zutil.h zlib.h zconf.h inftrees.h +minigzip.obj : [.test]minigzip.c zlib.h zconf.h +trees.obj : trees.c deflate.h zutil.h zlib.h zconf.h +uncompr.obj : uncompr.c zlib.h zconf.h +zutil.obj : zutil.c zutil.h zlib.h zconf.h +infback.obj : infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h +$ eod +$ close out +$ return +$!------------------------------------------------------------------------------ +$! +$! Read list of core library sources from makefile.in and create options +$! needed to build shareable image +$! +$CREA_OLIST: +$ open/read min makefile.in +$ open/write mod modules.opt +$ src_check_list = "OBJZ =#OBJG =" +$MRLOOP: +$ read/end=mrdone min rec +$ i = 0 +$SRC_CHECK_LOOP: +$ src_check = f$element(i, "#", src_check_list) +$ i = i+1 +$ if src_check .eqs. "#" then goto mrloop +$ if (f$extract(0,6,rec) .nes. src_check) then goto src_check_loop +$ rec = rec - src_check +$ gosub extra_filnam +$ if (f$element(1,"\",rec) .eqs. "\") then goto mrloop +$MRSLOOP: +$ read/end=mrdone min rec +$ gosub extra_filnam +$ if (f$element(1,"\",rec) .nes. "\") then goto mrsloop +$MRDONE: +$ close min +$ close mod +$ return +$!------------------------------------------------------------------------------ +$! +$! Take record extracted in crea_olist and split it into single filenames +$! +$EXTRA_FILNAM: +$ myrec = f$edit(rec - "\", "trim,compress") +$ i = 0 +$FELOOP: +$ srcfil = f$element(i," ", myrec) +$ if (srcfil .nes. " ") +$ then +$ write mod f$parse(srcfil,,,"NAME"), ".obj" +$ i = i + 1 +$ goto feloop +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! Find current Zlib version number +$! +$FIND_VERSION: +$ open/read h_in 'v_file' +$hloop: +$ read/end=hdone h_in rec +$ rec = f$edit(rec,"TRIM") +$ if (f$extract(0,1,rec) .nes. "#") then goto hloop +$ rec = f$edit(rec - "#", "TRIM") +$ if f$element(0," ",rec) .nes. "define" then goto hloop +$ if f$element(1," ",rec) .eqs. v_string +$ then +$ version = 'f$element(2," ",rec)' +$ goto hdone +$ endif +$ goto hloop +$hdone: +$ close h_in +$ return +$!------------------------------------------------------------------------------ +$! +$CHECK_CONFIG: +$! +$ in_ldef = f$locate(cdef,libdefs) +$ if (in_ldef .lt. f$length(libdefs)) +$ then +$ write aconf "#define ''cdef' 1" +$ libdefs = f$extract(0,in_ldef,libdefs) + - + f$extract(in_ldef + f$length(cdef) + 1, - + f$length(libdefs) - in_ldef - f$length(cdef) - 1, - + libdefs) +$ else +$ if (f$type('cdef') .eqs. "INTEGER") +$ then +$ write aconf "#define ''cdef' ", 'cdef' +$ else +$ if (f$type('cdef') .eqs. "STRING") +$ then +$ write aconf "#define ''cdef' ", """", '''cdef'', """" +$ else +$ gosub check_cc_def +$ endif +$ endif +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! Check if this is a define relating to the properties of the C/C++ +$! compiler +$! +$ CHECK_CC_DEF: +$ if (cdef .eqs. "_LARGEFILE64_SOURCE") +$ then +$ copy sys$input: 'tc' +$ deck +#include "tconfig" +#define _LARGEFILE +#include + +int main(){ +FILE *fp; + fp = fopen("temp.txt","r"); + fseeko(fp,1,SEEK_SET); + fclose(fp); +} + +$ eod +$ test_inv = false +$ comm_h = false +$ gosub cc_prop_check +$ return +$ endif +$ write aconf "/* ", line, " */" +$ return +$!------------------------------------------------------------------------------ +$! +$! Check for properties of C/C++ compiler +$! +$! Version history +$! 0.01 20031020 First version to receive a number +$! 0.02 20031022 Added logic for defines with value +$! 0.03 20040309 Make sure local config file gets not deleted +$! 0.04 20041230 Also write include for configure run +$! 0.05 20050103 Add processing of "comment defines" +$CC_PROP_CHECK: +$ cc_prop = true +$ is_need = false +$ is_need = (f$extract(0,4,cdef) .eqs. "NEED") .or. (test_inv .eq. true) +$ if f$search(th) .eqs. "" then create 'th' +$ set message/nofac/noident/nosever/notext +$ on error then continue +$ cc 'tmpnam' +$ if .not. ($status) then cc_prop = false +$ on error then continue +$! The headers might lie about the capabilities of the RTL +$ link 'tmpnam',tmp.opt/opt +$ if .not. ($status) then cc_prop = false +$ set message/fac/ident/sever/text +$ on error then goto err_exit +$ delete/nolog 'tmpnam'.*;*/exclude='th' +$ if (cc_prop .and. .not. is_need) .or. - + (.not. cc_prop .and. is_need) +$ then +$ write sys$output "Checking for ''cdef'... yes" +$ if f$type('cdef_val'_yes) .nes. "" +$ then +$ if f$type('cdef_val'_yes) .eqs. "INTEGER" - + then call write_config f$fao("#define !AS !UL",cdef,'cdef_val'_yes) +$ if f$type('cdef_val'_yes) .eqs. "STRING" - + then call write_config f$fao("#define !AS !AS",cdef,'cdef_val'_yes) +$ else +$ call write_config f$fao("#define !AS 1",cdef) +$ endif +$ if (cdef .eqs. "HAVE_FSEEKO") .or. (cdef .eqs. "_LARGE_FILES") .or. - + (cdef .eqs. "_LARGEFILE64_SOURCE") then - + call write_config f$string("#define _LARGEFILE 1") +$ else +$ write sys$output "Checking for ''cdef'... no" +$ if (comm_h) +$ then + call write_config f$fao("/* !AS */",line) +$ else +$ if f$type('cdef_val'_no) .nes. "" +$ then +$ if f$type('cdef_val'_no) .eqs. "INTEGER" - + then call write_config f$fao("#define !AS !UL",cdef,'cdef_val'_no) +$ if f$type('cdef_val'_no) .eqs. "STRING" - + then call write_config f$fao("#define !AS !AS",cdef,'cdef_val'_no) +$ else +$ call write_config f$fao("#undef !AS",cdef) +$ endif +$ endif +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! Check for properties of C/C++ compiler with multiple result values +$! +$! Version history +$! 0.01 20040127 First version +$! 0.02 20050103 Reconcile changes from cc_prop up to version 0.05 +$CC_MPROP_CHECK: +$ cc_prop = true +$ i = 1 +$ idel = 1 +$ MT_LOOP: +$ if f$type(result_'i') .eqs. "STRING" +$ then +$ set message/nofac/noident/nosever/notext +$ on error then continue +$ cc 'tmpnam'_'i' +$ if .not. ($status) then cc_prop = false +$ on error then continue +$! The headers might lie about the capabilities of the RTL +$ link 'tmpnam'_'i',tmp.opt/opt +$ if .not. ($status) then cc_prop = false +$ set message/fac/ident/sever/text +$ on error then goto err_exit +$ delete/nolog 'tmpnam'_'i'.*;* +$ if (cc_prop) +$ then +$ write sys$output "Checking for ''cdef'... ", mdef_'i' +$ if f$type(mdef_'i') .eqs. "INTEGER" - + then call write_config f$fao("#define !AS !UL",cdef,mdef_'i') +$ if f$type('cdef_val'_yes) .eqs. "STRING" - + then call write_config f$fao("#define !AS !AS",cdef,mdef_'i') +$ goto msym_clean +$ else +$ i = i + 1 +$ goto mt_loop +$ endif +$ endif +$ write sys$output "Checking for ''cdef'... no" +$ call write_config f$fao("#undef !AS",cdef) +$ MSYM_CLEAN: +$ if (idel .le. msym_max) +$ then +$ delete/sym mdef_'idel' +$ idel = idel + 1 +$ goto msym_clean +$ endif +$ return +$!------------------------------------------------------------------------------ +$! +$! Write configuration to both permanent and temporary config file +$! +$! Version history +$! 0.01 20031029 First version to receive a number +$! +$WRITE_CONFIG: SUBROUTINE +$ write aconf 'p1' +$ open/append confh 'th' +$ write confh 'p1' +$ close confh +$ENDSUBROUTINE +$!------------------------------------------------------------------------------ +$! +$! Analyze the project map file and create the symbol vector for a shareable +$! image from it +$! +$! Version history +$! 0.01 20120128 First version +$! 0.02 20120226 Add pre-load logic +$! +$ MAP_2_SHOPT: Subroutine +$! +$ SAY := "WRITE_ SYS$OUTPUT" +$! +$ IF F$SEARCH("''P1'") .EQS. "" +$ THEN +$ SAY "MAP_2_SHOPT-E-NOSUCHFILE: Error, inputfile ''p1' not available" +$ goto exit_m2s +$ ENDIF +$ IF "''P2'" .EQS. "" +$ THEN +$ SAY "MAP_2_SHOPT: Error, no output file provided" +$ goto exit_m2s +$ ENDIF +$! +$ module1 = "deflate#deflateEnd#deflateInit_#deflateParams#deflateSetDictionary" +$ module2 = "gzclose#gzerror#gzgetc#gzgets#gzopen#gzprintf#gzputc#gzputs#gzread" +$ module3 = "gzseek#gztell#inflate#inflateEnd#inflateInit_#inflateSetDictionary" +$ module4 = "inflateSync#uncompress#zlibVersion#compress" +$ open/read map 'p1 +$ if axp .or. ia64 +$ then +$ open/write aopt a.opt +$ open/write bopt b.opt +$ write aopt " CASE_SENSITIVE=YES" +$ write bopt "SYMBOL_VECTOR= (-" +$ mod_sym_num = 1 +$ MOD_SYM_LOOP: +$ if f$type(module'mod_sym_num') .nes. "" +$ then +$ mod_in = 0 +$ MOD_SYM_IN: +$ shared_proc = f$element(mod_in, "#", module'mod_sym_num') +$ if shared_proc .nes. "#" +$ then +$ write aopt f$fao(" symbol_vector=(!AS/!AS=PROCEDURE)",- + f$edit(shared_proc,"upcase"),shared_proc) +$ write bopt f$fao("!AS=PROCEDURE,-",shared_proc) +$ mod_in = mod_in + 1 +$ goto mod_sym_in +$ endif +$ mod_sym_num = mod_sym_num + 1 +$ goto mod_sym_loop +$ endif +$MAP_LOOP: +$ read/end=map_end map line +$ if (f$locate("{",line).lt. f$length(line)) .or. - + (f$locate("global:", line) .lt. f$length(line)) +$ then +$ proc = true +$ goto map_loop +$ endif +$ if f$locate("}",line).lt. f$length(line) then proc = false +$ if f$locate("local:", line) .lt. f$length(line) then proc = false +$ if proc +$ then +$ shared_proc = f$edit(line,"collapse") +$ chop_semi = f$locate(";", shared_proc) +$ if chop_semi .lt. f$length(shared_proc) then - + shared_proc = f$extract(0, chop_semi, shared_proc) +$ write aopt f$fao(" symbol_vector=(!AS/!AS=PROCEDURE)",- + f$edit(shared_proc,"upcase"),shared_proc) +$ write bopt f$fao("!AS=PROCEDURE,-",shared_proc) +$ endif +$ goto map_loop +$MAP_END: +$ close/nolog aopt +$ close/nolog bopt +$ open/append libopt 'p2' +$ open/read aopt a.opt +$ open/read bopt b.opt +$ALOOP: +$ read/end=aloop_end aopt line +$ write libopt line +$ goto aloop +$ALOOP_END: +$ close/nolog aopt +$ sv = "" +$BLOOP: +$ read/end=bloop_end bopt svn +$ if (svn.nes."") +$ then +$ if (sv.nes."") then write libopt sv +$ sv = svn +$ endif +$ goto bloop +$BLOOP_END: +$ write libopt f$extract(0,f$length(sv)-2,sv), "-" +$ write libopt ")" +$ close/nolog bopt +$ delete/nolog/noconf a.opt;*,b.opt;* +$ else +$ if vax +$ then +$ open/append libopt 'p2' +$ mod_sym_num = 1 +$ VMOD_SYM_LOOP: +$ if f$type(module'mod_sym_num') .nes. "" +$ then +$ mod_in = 0 +$ VMOD_SYM_IN: +$ shared_proc = f$element(mod_in, "#", module'mod_sym_num') +$ if shared_proc .nes. "#" +$ then +$ write libopt f$fao("UNIVERSAL=!AS",- + f$edit(shared_proc,"upcase")) +$ mod_in = mod_in + 1 +$ goto vmod_sym_in +$ endif +$ mod_sym_num = mod_sym_num + 1 +$ goto vmod_sym_loop +$ endif +$VMAP_LOOP: +$ read/end=vmap_end map line +$ if (f$locate("{",line).lt. f$length(line)) .or. - + (f$locate("global:", line) .lt. f$length(line)) +$ then +$ proc = true +$ goto vmap_loop +$ endif +$ if f$locate("}",line).lt. f$length(line) then proc = false +$ if f$locate("local:", line) .lt. f$length(line) then proc = false +$ if proc +$ then +$ shared_proc = f$edit(line,"collapse") +$ chop_semi = f$locate(";", shared_proc) +$ if chop_semi .lt. f$length(shared_proc) then - + shared_proc = f$extract(0, chop_semi, shared_proc) +$ write libopt f$fao("UNIVERSAL=!AS",- + f$edit(shared_proc,"upcase")) +$ endif +$ goto vmap_loop +$VMAP_END: +$ else +$ write sys$output "Unknown Architecture (Not VAX, AXP, or IA64)" +$ write sys$output "No options file created" +$ endif +$ endif +$ EXIT_M2S: +$ close/nolog map +$ close/nolog libopt +$ endsubroutine diff --git a/zlib/src/treebuild.xml b/zlib/src/treebuild.xml new file mode 100644 index 0000000..38d29d7 --- /dev/null +++ b/zlib/src/treebuild.xml @@ -0,0 +1,116 @@ + + + + zip compression library + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/zlib/src/trees.c b/zlib/src/trees.c new file mode 100644 index 0000000..1fd7759 --- /dev/null +++ b/zlib/src/trees.c @@ -0,0 +1,1226 @@ +/* trees.c -- output deflated data using Huffman coding + * Copyright (C) 1995-2012 Jean-loup Gailly + * detect_data_type() function provided freely by Cosmin Truta, 2006 + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process uses several Huffman trees. The more + * common source values are represented by shorter bit sequences. + * + * Each code tree is stored in a compressed form which is itself + * a Huffman encoding of the lengths of all the code strings (in + * ascending order by source values). The actual code strings are + * reconstructed from the lengths in the inflate process, as described + * in the deflate specification. + * + * REFERENCES + * + * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". + * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc + * + * Storer, James A. + * Data Compression: Methods and Theory, pp. 49-50. + * Computer Science Press, 1988. ISBN 0-7167-8156-5. + * + * Sedgewick, R. + * Algorithms, p290. + * Addison-Wesley, 1983. ISBN 0-201-06672-6. + */ + +/* @(#) $Id$ */ + +/* #define GEN_TREES_H */ + +#include "deflate.h" + +#ifdef DEBUG +# include +#endif + +/* =========================================================================== + * Constants + */ + +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +#define END_BLOCK 256 +/* end of block literal code */ + +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +#define REPZ_11_138 18 +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = {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}; + +local const int extra_dbits[D_CODES] /* extra bits for each distance code */ + = {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}; + +local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ + = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + +local const uch bl_order[BL_CODES] + = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ + +#if defined(GEN_TREES_H) || !defined(STDC) +/* non ANSI compilers may not accept trees.h */ + +local ct_data static_ltree[L_CODES+2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +local ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +uch _dist_code[DIST_CODE_LEN]; +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +uch _length_code[MAX_MATCH-MIN_MATCH+1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +local int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +local int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + +#else +# include "trees.h" +#endif /* GEN_TREES_H */ + +struct static_tree_desc_s { + const ct_data *static_tree; /* static tree or NULL */ + const intf *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ +}; + +local static_tree_desc static_l_desc = +{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; + +local static_tree_desc static_d_desc = +{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; + +local static_tree_desc static_bl_desc = +{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; + +/* =========================================================================== + * Local (static) routines in this file. + */ + +local void tr_static_init OF((void)); +local void init_block OF((deflate_state *s)); +local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); +local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); +local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); +local void build_tree OF((deflate_state *s, tree_desc *desc)); +local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local int build_bl_tree OF((deflate_state *s)); +local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, + int blcodes)); +local void compress_block OF((deflate_state *s, const ct_data *ltree, + const ct_data *dtree)); +local int detect_data_type OF((deflate_state *s)); +local unsigned bi_reverse OF((unsigned value, int length)); +local void bi_windup OF((deflate_state *s)); +local void bi_flush OF((deflate_state *s)); +local void copy_block OF((deflate_state *s, charf *buf, unsigned len, + int header)); + +#ifdef GEN_TREES_H +local void gen_trees_header OF((void)); +#endif + +#ifndef DEBUG +# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) + /* Send a code of the given tree. c and tree must not have side effects */ + +#else /* DEBUG */ +# define send_code(s, c, tree) \ + { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ + send_bits(s, tree[c].Code, tree[c].Len); } +#endif + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +#define put_short(s, w) { \ + put_byte(s, (uch)((w) & 0xff)); \ + put_byte(s, (uch)((ush)(w) >> 8)); \ +} + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +#ifdef DEBUG +local void send_bits OF((deflate_state *s, int value, int length)); + +local void send_bits(s, value, length) + deflate_state *s; + int value; /* value to send */ + int length; /* number of bits */ +{ + Tracevv((stderr," l %2d v %4x ", length, value)); + Assert(length > 0 && length <= 15, "invalid length"); + s->bits_sent += (ulg)length; + + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if (s->bi_valid > (int)Buf_size - length) { + s->bi_buf |= (ush)value << s->bi_valid; + put_short(s, s->bi_buf); + s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); + s->bi_valid += length - Buf_size; + } else { + s->bi_buf |= (ush)value << s->bi_valid; + s->bi_valid += length; + } +} +#else /* !DEBUG */ + +#define send_bits(s, value, length) \ +{ int len = length;\ + if (s->bi_valid > (int)Buf_size - len) {\ + int val = value;\ + s->bi_buf |= (ush)val << s->bi_valid;\ + put_short(s, s->bi_buf);\ + s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ + s->bi_valid += len - Buf_size;\ + } else {\ + s->bi_buf |= (ush)(value) << s->bi_valid;\ + s->bi_valid += len;\ + }\ +} +#endif /* DEBUG */ + + +/* the arguments must not have side effects */ + +/* =========================================================================== + * Initialize the various 'constant' tables. + */ +local void tr_static_init() +{ +#if defined(GEN_TREES_H) || !defined(STDC) + static int static_init_done = 0; + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + if (static_init_done) return; + + /* For some embedded targets, global variables are not initialized: */ +#ifdef NO_INIT_GLOBAL_POINTERS + static_l_desc.static_tree = static_ltree; + static_l_desc.extra_bits = extra_lbits; + static_d_desc.static_tree = static_dtree; + static_d_desc.extra_bits = extra_dbits; + static_bl_desc.extra_bits = extra_blbits; +#endif + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1< dist code (0..29) */ + dist = 0; + for (code = 0 ; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ + for ( ; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + _dist_code[256 + dist++] = (uch)code; + } + } + Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = bi_reverse((unsigned)n, 5); + } + static_init_done = 1; + +# ifdef GEN_TREES_H + gen_trees_header(); +# endif +#endif /* defined(GEN_TREES_H) || !defined(STDC) */ +} + +/* =========================================================================== + * Genererate the file trees.h describing the static trees. + */ +#ifdef GEN_TREES_H +# ifndef DEBUG +# include +# endif + +# define SEPARATOR(i, last, width) \ + ((i) == (last)? "\n};\n\n" : \ + ((i) % (width) == (width)-1 ? ",\n" : ", ")) + +void gen_trees_header() +{ + FILE *header = fopen("trees.h", "w"); + int i; + + Assert (header != NULL, "Can't open trees.h"); + fprintf(header, + "/* header created automatically with -DGEN_TREES_H */\n\n"); + + fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); + for (i = 0; i < L_CODES+2; i++) { + fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, + static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + } + + fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, + static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + } + + fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); + for (i = 0; i < DIST_CODE_LEN; i++) { + fprintf(header, "%2u%s", _dist_code[i], + SEPARATOR(i, DIST_CODE_LEN-1, 20)); + } + + fprintf(header, + "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); + for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + fprintf(header, "%2u%s", _length_code[i], + SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + } + + fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); + for (i = 0; i < LENGTH_CODES; i++) { + fprintf(header, "%1u%s", base_length[i], + SEPARATOR(i, LENGTH_CODES-1, 20)); + } + + fprintf(header, "local const int base_dist[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "%5u%s", base_dist[i], + SEPARATOR(i, D_CODES-1, 10)); + } + + fclose(header); +} +#endif /* GEN_TREES_H */ + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +void ZLIB_INTERNAL _tr_init(s) + deflate_state *s; +{ + tr_static_init(); + + s->l_desc.dyn_tree = s->dyn_ltree; + s->l_desc.stat_desc = &static_l_desc; + + s->d_desc.dyn_tree = s->dyn_dtree; + s->d_desc.stat_desc = &static_d_desc; + + s->bl_desc.dyn_tree = s->bl_tree; + s->bl_desc.stat_desc = &static_bl_desc; + + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->compressed_len = 0L; + s->bits_sent = 0L; +#endif + + /* Initialize the first block of the first file: */ + init_block(s); +} + +/* =========================================================================== + * Initialize a new block. + */ +local void init_block(s) + deflate_state *s; +{ + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; + + s->dyn_ltree[END_BLOCK].Freq = 1; + s->opt_len = s->static_len = 0L; + s->last_lit = s->matches = 0; +} + +#define SMALLEST 1 +/* Index within the heap array of least frequent node in the Huffman tree */ + + +/* =========================================================================== + * Remove the smallest element from the heap and recreate the heap with + * one less element. Updates heap and heap_len. + */ +#define pqremove(s, tree, top) \ +{\ + top = s->heap[SMALLEST]; \ + s->heap[SMALLEST] = s->heap[s->heap_len--]; \ + pqdownheap(s, tree, SMALLEST); \ +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +#define smaller(tree, n, m, depth) \ + (tree[n].Freq < tree[m].Freq || \ + (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +local void pqdownheap(s, tree, k) + deflate_state *s; + ct_data *tree; /* the tree to restore */ + int k; /* node to move down */ +{ + int v = s->heap[k]; + int j = k << 1; /* left son of k */ + while (j <= s->heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s->heap_len && + smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s->heap[j], s->depth)) break; + + /* Exchange v with the smallest son */ + s->heap[k] = s->heap[j]; k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s->heap[k] = v; +} + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +local void gen_bitlen(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + int max_code = desc->max_code; + const ct_data *stree = desc->stat_desc->static_tree; + const intf *extra = desc->stat_desc->extra_bits; + int base = desc->stat_desc->extra_base; + int max_length = desc->stat_desc->max_length; + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ + + for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + n = s->heap[h]; + bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) bits = max_length, overflow++; + tree[n].Len = (ush)bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) continue; /* not a leaf node */ + + s->bl_count[bits]++; + xbits = 0; + if (n >= base) xbits = extra[n-base]; + f = tree[n].Freq; + s->opt_len += (ulg)f * (bits + xbits); + if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); + } + if (overflow == 0) return; + + Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length-1; + while (s->bl_count[bits] == 0) bits--; + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits != 0; bits--) { + n = s->bl_count[bits]; + while (n != 0) { + m = s->heap[--h]; + if (m > max_code) continue; + if ((unsigned) tree[m].Len != (unsigned) bits) { + Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s->opt_len += ((long)bits - (long)tree[m].Len) + *(long)tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; + } + } +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes (tree, max_code, bl_count) + ct_data *tree; /* the tree to decorate */ + int max_code; /* largest code with non zero frequency */ + ushf *bl_count; /* number of codes at each bit length */ +{ + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits-1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; + const ct_data *stree = desc->stat_desc->static_tree; + int elems = desc->stat_desc->elems; + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s->heap_len = 0, s->heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n].Freq != 0) { + s->heap[++(s->heap_len)] = max_code = n; + s->depth[n] = 0; + } else { + tree[n].Len = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s->heap_len < 2) { + node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); + tree[node].Freq = 1; + s->depth[node] = 0; + s->opt_len--; if (stree) s->static_len -= stree[node].Len; + /* node is 0 or 1 so it does not have extra bits */ + } + desc->max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + pqremove(s, tree, n); /* n = node of least frequency */ + m = s->heap[SMALLEST]; /* m = node of next least frequency */ + + s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ + s->heap[--(s->heap_max)] = m; + + /* Create a new node father of n and m */ + tree[node].Freq = tree[n].Freq + tree[m].Freq; + s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? + s->depth[n] : s->depth[m]) + 1); + tree[n].Dad = tree[m].Dad = (ush)node; +#ifdef DUMP_BL_TREE + if (tree == s->bl_tree) { + fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); + } +#endif + /* and insert the new node in the heap */ + s->heap[SMALLEST] = node++; + pqdownheap(s, tree, SMALLEST); + + } while (s->heap_len >= 2); + + s->heap[--(s->heap_max)] = s->heap[SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, (tree_desc *)desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes ((ct_data *)tree, max_code, s->bl_count); +} + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +local void scan_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + if (nextlen == 0) max_count = 138, min_count = 3; + tree[max_code+1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + s->bl_tree[curlen].Freq += count; + } else if (curlen != 0) { + if (curlen != prevlen) s->bl_tree[curlen].Freq++; + s->bl_tree[REP_3_6].Freq++; + } else if (count <= 10) { + s->bl_tree[REPZ_3_10].Freq++; + } else { + s->bl_tree[REPZ_11_138].Freq++; + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +local void send_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen == 0) max_count = 138, min_count = 3; + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { send_code(s, curlen, s->bl_tree); } while (--count != 0); + + } else if (curlen != 0) { + if (curlen != prevlen) { + send_code(s, curlen, s->bl_tree); count--; + } + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); + + } else { + send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +local int build_bl_tree(s) + deflate_state *s; +{ + int max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); + scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, (tree_desc *)(&(s->bl_desc))); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ + s->opt_len += 3*(max_blindex+1) + 5+5+4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + s->opt_len, s->static_len)); + + return max_blindex; +} + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +local void send_all_trees(s, lcodes, dcodes, blcodes) + deflate_state *s; + int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + int rank; /* index in bl_order */ + + Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); + Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5); + send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); + } + Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + +/* =========================================================================== + * Send a stored block + */ +void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +#ifdef DEBUG + s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; + s->compressed_len += (stored_len + 4) << 3; +#endif + copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ +} + +/* =========================================================================== + * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) + */ +void ZLIB_INTERNAL _tr_flush_bits(s) + deflate_state *s; +{ + bi_flush(s); +} + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +void ZLIB_INTERNAL _tr_align(s) + deflate_state *s; +{ + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +#ifdef DEBUG + s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ +#endif + bi_flush(s); +} + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block, or NULL if too old */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + int max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s->level > 0) { + + /* Check if the file is binary or text */ + if (s->strm->data_type == Z_UNKNOWN) + s->strm->data_type = detect_data_type(s); + + /* Construct the literal and distance trees */ + build_tree(s, (tree_desc *)(&(s->l_desc))); + Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + + build_tree(s, (tree_desc *)(&(s->d_desc))); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s->opt_len+3+7)>>3; + static_lenb = (s->static_len+3+7)>>3; + + Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + s->last_lit)); + + if (static_lenb <= opt_lenb) opt_lenb = static_lenb; + + } else { + Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + +#ifdef FORCE_STORED + if (buf != (char*)0) { /* force stored block */ +#else + if (stored_len+4 <= opt_lenb && buf != (char*)0) { + /* 4: two words for the lengths */ +#endif + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + +#ifdef FORCE_STATIC + } else if (static_lenb >= 0) { /* force static trees */ +#else + } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { +#endif + send_bits(s, (STATIC_TREES<<1)+last, 3); + compress_block(s, (const ct_data *)static_ltree, + (const ct_data *)static_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->static_len; +#endif + } else { + send_bits(s, (DYN_TREES<<1)+last, 3); + send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, + max_blindex+1); + compress_block(s, (const ct_data *)s->dyn_ltree, + (const ct_data *)s->dyn_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->opt_len; +#endif + } + Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); +#ifdef DEBUG + s->compressed_len += 7; /* align on byte boundary */ +#endif + } + Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +int ZLIB_INTERNAL _tr_tally (s, dist, lc) + deflate_state *s; + unsigned dist; /* distance of matched string */ + unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + s->d_buf[s->last_lit] = (ush)dist; + s->l_buf[s->last_lit++] = (uch)lc; + if (dist == 0) { + /* lc is the unmatched char */ + s->dyn_ltree[lc].Freq++; + } else { + s->matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + Assert((ush)dist < (ush)MAX_DIST(s) && + (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_dtree[d_code(dist)].Freq++; + } + +#ifdef TRUNCATE_BLOCK + /* Try to guess if it is profitable to stop the current block here */ + if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { + /* Compute an upper bound for the compressed length */ + ulg out_length = (ulg)s->last_lit*8L; + ulg in_length = (ulg)((long)s->strstart - s->block_start); + int dcode; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += (ulg)s->dyn_dtree[dcode].Freq * + (5L+extra_dbits[dcode]); + } + out_length >>= 3; + Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", + s->last_lit, in_length, out_length, + 100L - out_length*100L/in_length)); + if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; + } +#endif + return (s->last_lit == s->lit_bufsize-1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(s, ltree, dtree) + deflate_state *s; + const ct_data *ltree; /* literal tree */ + const ct_data *dtree; /* distance tree */ +{ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (s->last_lit != 0) do { + dist = s->d_buf[lx]; + lc = s->l_buf[lx++]; + if (dist == 0) { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code+LITERALS+1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + "pendingBuf overflow"); + + } while (lx < s->last_lit); + + send_code(s, END_BLOCK, ltree); +} + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +local int detect_data_type(s) + deflate_state *s; +{ + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + unsigned long black_mask = 0xf3ffc07fUL; + int n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>= 1) + if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) + return Z_BINARY; + + /* Check for textual ("white-listed") bytes. */ + if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 + || s->dyn_ltree[13].Freq != 0) + return Z_TEXT; + for (n = 32; n < LITERALS; n++) + if (s->dyn_ltree[n].Freq != 0) + return Z_TEXT; + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +local unsigned bi_reverse(code, len) + unsigned code; /* the value to invert */ + int len; /* its bit length */ +{ + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +local void bi_flush(s) + deflate_state *s; +{ + if (s->bi_valid == 16) { + put_short(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else if (s->bi_valid >= 8) { + put_byte(s, (Byte)s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } +} + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +local void bi_windup(s) + deflate_state *s; +{ + if (s->bi_valid > 8) { + put_short(s, s->bi_buf); + } else if (s->bi_valid > 0) { + put_byte(s, (Byte)s->bi_buf); + } + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->bits_sent = (s->bits_sent+7) & ~7; +#endif +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +local void copy_block(s, buf, len, header) + deflate_state *s; + charf *buf; /* the input data */ + unsigned len; /* its length */ + int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, (ush)len); + put_short(s, (ush)~len); +#ifdef DEBUG + s->bits_sent += 2*16; +#endif + } +#ifdef DEBUG + s->bits_sent += (ulg)len<<3; +#endif + while (len--) { + put_byte(s, *buf++); + } +} diff --git a/zlib/src/trees.h b/zlib/src/trees.h new file mode 100644 index 0000000..d35639d --- /dev/null +++ b/zlib/src/trees.h @@ -0,0 +1,128 @@ +/* header created automatically with -DGEN_TREES_H */ + +local const ct_data static_ltree[L_CODES+2] = { +{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +}; + +local const ct_data static_dtree[D_CODES] = { +{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +}; + +const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { + 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, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 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, 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, 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, +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 +}; + +const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 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, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +local const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +local const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + diff --git a/zlib/src/uncompr.c b/zlib/src/uncompr.c new file mode 100644 index 0000000..242e949 --- /dev/null +++ b/zlib/src/uncompr.c @@ -0,0 +1,59 @@ +/* uncompr.c -- decompress a memory buffer + * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted. +*/ +int ZEXPORT uncompress (dest, destLen, source, sourceLen) + Bytef *dest; + uLongf *destLen; + const Bytef *source; + uLong sourceLen; +{ + z_stream stream; + int err; + + stream.next_in = (z_const Bytef *)source; + stream.avail_in = (uInt)sourceLen; + /* Check for source > 64K on 16-bit machine: */ + if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; + + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + + err = inflateInit(&stream); + if (err != Z_OK) return err; + + err = inflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + inflateEnd(&stream); + if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) + return Z_DATA_ERROR; + return err; + } + *destLen = stream.total_out; + + err = inflateEnd(&stream); + return err; +} diff --git a/zlib/src/zconf.h b/zlib/src/zconf.h new file mode 100644 index 0000000..9987a77 --- /dev/null +++ b/zlib/src/zconf.h @@ -0,0 +1,511 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2013 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzvprintf z_gzvprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateGetDictionary z_inflateGetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/zlib/src/zconf.h.cmakein b/zlib/src/zconf.h.cmakein new file mode 100644 index 0000000..043019c --- /dev/null +++ b/zlib/src/zconf.h.cmakein @@ -0,0 +1,513 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2013 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H +#cmakedefine Z_PREFIX +#cmakedefine Z_HAVE_UNISTD_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzvprintf z_gzvprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateGetDictionary z_inflateGetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/zlib/src/zconf.h.in b/zlib/src/zconf.h.in new file mode 100644 index 0000000..9987a77 --- /dev/null +++ b/zlib/src/zconf.h.in @@ -0,0 +1,511 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2013 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzvprintf z_gzvprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateGetDictionary z_inflateGetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/zlib/src/zlib.3 b/zlib/src/zlib.3 new file mode 100644 index 0000000..0160e62 --- /dev/null +++ b/zlib/src/zlib.3 @@ -0,0 +1,151 @@ +.TH ZLIB 3 "28 Apr 2013" +.SH NAME +zlib \- compression/decompression library +.SH SYNOPSIS +[see +.I zlib.h +for full description] +.SH DESCRIPTION +The +.I zlib +library is a general purpose data compression library. +The code is thread safe, assuming that the standard library functions +used are thread safe, such as memory allocation routines. +It provides in-memory compression and decompression functions, +including integrity checks of the uncompressed data. +This version of the library supports only one compression method (deflation) +but other algorithms may be added later +with the same stream interface. +.LP +Compression can be done in a single step if the buffers are large enough +or can be done by repeated calls of the compression function. +In the latter case, +the application must provide more input and/or consume the output +(providing more output space) before each call. +.LP +The library also supports reading and writing files in +.IR gzip (1) +(.gz) format +with an interface similar to that of stdio. +.LP +The library does not install any signal handler. +The decoder checks the consistency of the compressed data, +so the library should never crash even in the case of corrupted input. +.LP +All functions of the compression library are documented in the file +.IR zlib.h . +The distribution source includes examples of use of the library +in the files +.I test/example.c +and +.IR test/minigzip.c, +as well as other examples in the +.IR examples/ +directory. +.LP +Changes to this version are documented in the file +.I ChangeLog +that accompanies the source. +.LP +.I zlib +is available in Java using the java.util.zip package: +.IP +http://java.sun.com/developer/technicalArticles/Programming/compression/ +.LP +A Perl interface to +.IR zlib , +written by Paul Marquess (pmqs@cpan.org), +is available at CPAN (Comprehensive Perl Archive Network) sites, +including: +.IP +http://search.cpan.org/~pmqs/IO-Compress-Zlib/ +.LP +A Python interface to +.IR zlib , +written by A.M. Kuchling (amk@magnet.com), +is available in Python 1.5 and later versions: +.IP +http://docs.python.org/library/zlib.html +.LP +.I zlib +is built into +.IR tcl: +.IP +http://wiki.tcl.tk/4610 +.LP +An experimental package to read and write files in .zip format, +written on top of +.I zlib +by Gilles Vollant (info@winimage.com), +is available at: +.IP +http://www.winimage.com/zLibDll/minizip.html +and also in the +.I contrib/minizip +directory of the main +.I zlib +source distribution. +.SH "SEE ALSO" +The +.I zlib +web site can be found at: +.IP +http://zlib.net/ +.LP +The data format used by the zlib library is described by RFC +(Request for Comments) 1950 to 1952 in the files: +.IP +http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format) +.br +http://tools.ietf.org/html/rfc1951 (for the deflate compressed data format) +.br +http://tools.ietf.org/html/rfc1952 (for the gzip header and trailer format) +.LP +Mark Nelson wrote an article about +.I zlib +for the Jan. 1997 issue of Dr. Dobb's Journal; +a copy of the article is available at: +.IP +http://marknelson.us/1997/01/01/zlib-engine/ +.SH "REPORTING PROBLEMS" +Before reporting a problem, +please check the +.I zlib +web site to verify that you have the latest version of +.IR zlib ; +otherwise, +obtain the latest version and see if the problem still exists. +Please read the +.I zlib +FAQ at: +.IP +http://zlib.net/zlib_faq.html +.LP +before asking for help. +Send questions and/or comments to zlib@gzip.org, +or (for the Windows DLL version) to Gilles Vollant (info@winimage.com). +.SH AUTHORS +Version 1.2.8 +Copyright (C) 1995-2013 Jean-loup Gailly (jloup@gzip.org) +and Mark Adler (madler@alumni.caltech.edu). +.LP +This software is provided "as-is," +without any express or implied warranty. +In no event will the authors be held liable for any damages +arising from the use of this software. +See the distribution directory with respect to requirements +governing redistribution. +The deflate format used by +.I zlib +was defined by Phil Katz. +The deflate and +.I zlib +specifications were written by L. Peter Deutsch. +Thanks to all the people who reported problems and suggested various +improvements in +.IR zlib ; +who are too numerous to cite here. +.LP +UNIX manual page by R. P. C. Rodgers, +U.S. National Library of Medicine (rodgers@nlm.nih.gov). +.\" end of man page diff --git a/zlib/src/zlib.3.pdf b/zlib/src/zlib.3.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a346b5d7e24834806b0871b209637c728fb36d60 GIT binary patch literal 8734 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 literal 0 HcmV?d00001 diff --git a/zlib/src/zlib.h b/zlib/src/zlib.h new file mode 100644 index 0000000..3e0c767 --- /dev/null +++ b/zlib/src/zlib.h @@ -0,0 +1,1768 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.8, April 28th, 2013 + + Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.8" +#define ZLIB_VERNUM 0x1280 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 8 +#define ZLIB_VER_SUBREVISION 0 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed data. + This version of the library supports only one compression method (deflation) + but other algorithms will be added later and will have the same stream + interface. + + Compression can be done in a single step if the buffers are large enough, + or can be done by repeated calls of the compression function. In the latter + case, the application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never crash + even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total number of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has dropped + to zero. It must update next_out and avail_out when avail_out has dropped + to zero. The application must initialize zalloc, zfree and opaque before + calling the init function. All other fields are set by the compression + library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this if + the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers + returned by zalloc for objects of exactly 65536 bytes *must* have their + offset normalized to zero. The default allocation function provided by this + library ensures this (see zutil.c). To reduce memory requirements and avoid + any allocation of 64K objects, at the expense of compression ratio, compile + the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or progress + reports. After compression, total_in holds the total size of the + uncompressed data and may be saved for use in the decompressor (particularly + if the decompressor wants to decompress everything in a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +#define Z_TREES 6 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. This check + is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. If + zalloc and zfree are set to Z_NULL, deflateInit updates them to use default + allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at all + (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION + requests a default compromise between speed and compression (currently + equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if level is not a valid compression level, or + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). msg is set to null + if there is no error message. deflateInit does not perform any compression: + this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). Some + output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating avail_in or avail_out accordingly; avail_out should + never be zero before the call. The application can consume the compressed + output when it wants, for example when the output buffer is full (avail_out + == 0), or after each call of deflate(). If deflate returns Z_OK and with + zero avail_out, it must be called again after making room in the output + buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In + particular avail_in is zero after the call if enough output space has been + provided before the call.) Flushing may degrade compression for some + compression algorithms and so it should be used only when necessary. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed code + block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there was + enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the stream + are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least the + value returned by deflateBound (see below). Then deflate is guaranteed to + return Z_STREAM_END. If not enough output space is provided, deflate will + not return Z_STREAM_END, and it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect the + compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, msg + may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the + exact value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit() does not process any header information -- that is deferred + until inflate() is called. +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing will + resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there is + no more input data or no more space in the output buffer (see below about + the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating the next_* and avail_* values accordingly. The + application can consume the uncompressed output when it wants, for example + when the output buffer is full (avail_out == 0), or after each call of + inflate(). If inflate returns Z_OK and with zero avail_out, it must be + called again after making room in the output buffer because there might be + more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() + stop if and when it gets to the next deflate block boundary. When decoding + the zlib or gzip format, this will cause inflate() to return immediately + after the header and before the first block. When doing a raw inflate, + inflate() will go ahead and process the first block, and will return when it + gets to the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 if + inflate() is currently decoding the last block in the deflate stream, plus + 128 if inflate() returned immediately after decoding an end-of-block code or + decoding the complete header up to just before the first byte of the deflate + stream. The end-of-block will not be indicated until all of the uncompressed + data from that block has been written to strm->next_out. The number of + unused bits may in general be greater than seven, except when bit 7 of + data_type is set, in which case the number of unused bits will be less than + eight. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step (a + single call of inflate), the parameter flush should be set to Z_FINISH. In + this case all pending input is processed and all pending output is flushed; + avail_out must be large enough to hold all of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). Any information contained in the gzip + header is not retained, so applications that need that information should + instead use raw inflate, see inflateInit2() below, or inflateBack() and + perform their own processing of the gzip header and trailer. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + producted so far. The CRC-32 is checked against the gzip trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may + then call inflateSync() to look for a good compression block if a partial + recovery of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by the + caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), no + header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but is + slow and reduces compression ratio; memLevel=9 uses maximum memory for + optimal speed. The default value is 8. See zconf.h for total memory usage + as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as + fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The + strategy parameter only affects the compression ratio but not the + correctness of the compressed output even if it is not set appropriately. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is + incompatible with the version assumed by the caller (ZLIB_VERSION). msg is + set to null if there is no error message. deflateInit2 does not perform any + compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The + compressor and decompressor must use exactly the same dictionary (see + inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). deflateSetDictionary does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and can + consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. The + stream will keep the same compression level and any other attributes that + may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression level is changed, the input available so far is + compressed with the old level (and may be flushed); the new level will take + effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to be + compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if + strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the bits + leftover from a previous deflate stream when appending to it. As such, this + function can only be used for raw deflate, and must be used before the first + deflate() call after a deflateInit2() or deflateReset(). bits must be less + than or equal to 16, and that many of the least significant bits of value + will be inserted in the output. + + deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an adler32 or a crc32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a + crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, + Bytef *dictionary, + uInt *dictLength)); +/* + Returns the sliding dictionary being maintained by inflate. dictLength is + set to the number of bytes in the dictionary, and that many bytes are copied + to dictionary. dictionary must have enough space, where 32768 bytes is + always enough. If inflateGetDictionary() is called with dictionary equal to + Z_NULL, then only the dictionary length is returned, and nothing is copied. + Similary, if dictLength is Z_NULL, then it is not set. + + inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the + stream state is inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurrences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible full flush point has been found, + Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point + has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. + In the success case, the application may save the current current value of + total_in which indicates where valid compressed data was found. In the + error case, the application may repeatedly call inflateSync, providing more + input each time, until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. The + stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above or -1 << 16 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the parameters are invalid, Z_MEM_ERROR if the internal state could not be + allocated, or Z_VERSION_ERROR if the version of the library does not match + the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, + z_const unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is potentially more efficient than + inflate() for file i/o applications, in that it avoids copying between the + output and the sliding window by simply making the window itself the output + buffer. inflate() can be faster on modern CPUs when used with large + buffers. inflateBack() trusts the application to not change the output + buffer passed by the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free the + allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects only + the raw deflate stream to decompress. This is different from the normal + behavior of inflate(), which expects either a zlib or gzip header and + trailer around the deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero--buf is ignored in that + case--and inflateBack() will return a buffer error. inflateBack() will call + out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() + should return zero on success, or non-zero on failure. If out() returns + non-zero, inflateBack() will return with an error. Neither in() nor out() + are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format error + in the deflate stream (in which case strm->msg is set to indicate the nature + of the error), or Z_STREAM_ERROR if the stream was not properly initialized. + In the case of Z_BUF_ERROR, an input or output error can be distinguished + using strm->next_in which will be Z_NULL only if in() returned an error. If + strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning + non-zero. (in() will always be called before out(), so strm->next_in is + assured to be defined if out() returns non-zero.) Note that inflateBack() + cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + +#ifndef Z_SOLO + + /* utility functions */ + +/* + The following utility functions are implemented on top of the basic + stream-oriented functions. To simplify the interface, some default options + are assumed (compression level and memory usage, standard memory allocation + functions). The source code of these utility functions can be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before a + compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed buffer. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format with + an interface similar to that of stdio, using the functions that start with + "gz". The gzip format is different from the zlib format. gzip is a gzip + wrapper, documented in RFC 1952, wrapped around a deflate stream. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); + + Opens a gzip (.gz) file for reading or writing. The mode parameter is as + in fopen ("rb" or "wb") but can also include a compression level ("wb9") or + a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only + compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen associates a gzFile with the file descriptor fd. File descriptors + are obtained from calls like open, dup, creat, pipe or fileno (if the file + has been previously opened with fopen). The mode parameter is as in gzopen. + + The next call of gzclose on the returned gzFile will also close the file + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Two buffers are allocated, either both of the specified size when + writing, or one of the specified size and the other twice that size when + reading. A larger buffer size of, for example, 64K or 128K bytes will + noticeably increase the speed of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. If + the input file is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. +*/ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes written or 0 in case of + error. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or 0 in case of error. The number of + uncompressed bytes written is limited to 8191, or one less than the buffer + size given to gzbuffer(). The caller should assure that this limit is not + exceeded. If it is exceeded, then gzprintf() will return an error (0) with + nothing written. In this case, there may also be a buffer overflow with + unpredictable consequences, which is possible only if zlib was compiled with + the insecure functions sprintf() or vsprintf() because the secure snprintf() + or vsnprintf() functions were not available. This can be determined using + zlibCompileFlags(). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or a + newline character is read and transferred to buf, or an end-of-file + condition is encountered. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte or -1 + in case of end of file or error. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + The pushed character will be discarded if the stream is repositioned with + gzseek() or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatented gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); + + Sets the starting position for the next gzread or gzwrite on the given + compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); + + Returns the starting position for the next gzread or gzwrite on the given + compressed file. This position represents a number of bytes in the + uncompressed data stream, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the given + compressed file. errnum is set to zlib error number. If an error occurred + in the file system and not in the compression library, errnum is set to + Z_ERRNO and the application may consult errno to get the exact error code. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + +#endif /* !Z_SOLO */ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the compression + library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is Z_NULL, this function returns the + required initial value for the checksum. + + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. + + Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +/* +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_NULL, this function returns the required + initial value for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +/* +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ +#ifdef Z_PREFIX_SET +# undef z_gzgetc +# define z_gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#else +# define gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#endif + +/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if + * both are true, the application gets the *64 functions, and the regular + * functions are changed to 64 bits) -- in case these are set on systems + * without large file support, _LFS64_LARGEFILE must also be true + */ +#ifdef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +#endif + +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); + +#endif /* !Z_SOLO */ + +/* hack for buggy compilers */ +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; +#endif + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if defined(_WIN32) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, + const char *format, + va_list va)); +# endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/zlib/src/zlib.map b/zlib/src/zlib.map new file mode 100644 index 0000000..55c6647 --- /dev/null +++ b/zlib/src/zlib.map @@ -0,0 +1,83 @@ +ZLIB_1.2.0 { + global: + compressBound; + deflateBound; + inflateBack; + inflateBackEnd; + inflateBackInit_; + inflateCopy; + local: + deflate_copyright; + inflate_copyright; + inflate_fast; + inflate_table; + zcalloc; + zcfree; + z_errmsg; + gz_error; + gz_intmax; + _*; +}; + +ZLIB_1.2.0.2 { + gzclearerr; + gzungetc; + zlibCompileFlags; +} ZLIB_1.2.0; + +ZLIB_1.2.0.8 { + deflatePrime; +} ZLIB_1.2.0.2; + +ZLIB_1.2.2 { + adler32_combine; + crc32_combine; + deflateSetHeader; + inflateGetHeader; +} ZLIB_1.2.0.8; + +ZLIB_1.2.2.3 { + deflateTune; + gzdirect; +} ZLIB_1.2.2; + +ZLIB_1.2.2.4 { + inflatePrime; +} ZLIB_1.2.2.3; + +ZLIB_1.2.3.3 { + adler32_combine64; + crc32_combine64; + gzopen64; + gzseek64; + gztell64; + inflateUndermine; +} ZLIB_1.2.2.4; + +ZLIB_1.2.3.4 { + inflateReset2; + inflateMark; +} ZLIB_1.2.3.3; + +ZLIB_1.2.3.5 { + gzbuffer; + gzoffset; + gzoffset64; + gzclose_r; + gzclose_w; +} ZLIB_1.2.3.4; + +ZLIB_1.2.5.1 { + deflatePending; +} ZLIB_1.2.3.5; + +ZLIB_1.2.5.2 { + deflateResetKeep; + gzgetc_; + inflateResetKeep; +} ZLIB_1.2.5.1; + +ZLIB_1.2.7.1 { + inflateGetDictionary; + gzvprintf; +} ZLIB_1.2.5.2; diff --git a/zlib/src/zlib.pc.cmakein b/zlib/src/zlib.pc.cmakein new file mode 100644 index 0000000..a5e6429 --- /dev/null +++ b/zlib/src/zlib.pc.cmakein @@ -0,0 +1,13 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=@CMAKE_INSTALL_PREFIX@ +libdir=@INSTALL_LIB_DIR@ +sharedlibdir=@INSTALL_LIB_DIR@ +includedir=@INSTALL_INC_DIR@ + +Name: zlib +Description: zlib compression library +Version: @VERSION@ + +Requires: +Libs: -L${libdir} -L${sharedlibdir} -lz +Cflags: -I${includedir} diff --git a/zlib/src/zlib.pc.in b/zlib/src/zlib.pc.in new file mode 100644 index 0000000..7e5acf9 --- /dev/null +++ b/zlib/src/zlib.pc.in @@ -0,0 +1,13 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +sharedlibdir=@sharedlibdir@ +includedir=@includedir@ + +Name: zlib +Description: zlib compression library +Version: @VERSION@ + +Requires: +Libs: -L${libdir} -L${sharedlibdir} -lz +Cflags: -I${includedir} diff --git a/zlib/src/zlib.sdf b/zlib/src/zlib.sdf new file mode 100644 index 0000000000000000000000000000000000000000..361d9e0d93fa00931cf28d9491cb634783f8ebd0 GIT binary patch literal 24838144 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

T1_T-)|I}^@T~+!)7ZI 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

6FAqVRSmQccF9A$Q-)U{J}k&q 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%0DuY?Q!&!k6ag*jsoBdy? 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Π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

OV{9+n& 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