[
{
"path": ".gitignore",
"content": "build/\r\ncheatsUploader/\r\n.vscode/\r\nBACKUP/\r\ntest/\r\n*.elf\r\n*.nrp\r\n*.nacp\r\n*.nro\r\n*.zip\r\n*.ai\r\n"
},
{
"path": "LICENSE",
"content": " GNU GENERAL PUBLIC LICENSE\r\n Version 3, 29 June 2007\r\n\r\n Copyright (C) 2007 Free Software Foundation, Inc. \r\n Everyone is permitted to copy and distribute verbatim copies\r\n of this license document, but changing it is not allowed.\r\n\r\n Preamble\r\n\r\n The GNU General Public License is a free, copyleft license for\r\nsoftware and other kinds of works.\r\n\r\n The licenses for most software and other practical works are designed\r\nto take away your freedom to share and change the works. By contrast,\r\nthe GNU General Public License is intended to guarantee your freedom to\r\nshare and change all versions of a program--to make sure it remains free\r\nsoftware for all its users. We, the Free Software Foundation, use the\r\nGNU General Public License for most of our software; it applies also to\r\nany other work released this way by its authors. You can apply it to\r\nyour programs, too.\r\n\r\n When we speak of free software, we are referring to freedom, not\r\nprice. Our General Public Licenses are designed to make sure that you\r\nhave the freedom to distribute copies of free software (and charge for\r\nthem if you wish), that you receive source code or can get it if you\r\nwant it, that you can change the software or use pieces of it in new\r\nfree programs, and that you know you can do these things.\r\n\r\n To protect your rights, we need to prevent others from denying you\r\nthese rights or asking you to surrender the rights. Therefore, you have\r\ncertain responsibilities if you distribute copies of the software, or if\r\nyou modify it: responsibilities to respect the freedom of others.\r\n\r\n For example, if you distribute copies of such a program, whether\r\ngratis or for a fee, you must pass on to the recipients the same\r\nfreedoms that you received. You must make sure that they, too, receive\r\nor can get the source code. And you must show them these terms so they\r\nknow their rights.\r\n\r\n Developers that use the GNU GPL protect your rights with two steps:\r\n(1) assert copyright on the software, and (2) offer you this License\r\ngiving you legal permission to copy, distribute and/or modify it.\r\n\r\n For the developers' and authors' protection, the GPL clearly explains\r\nthat there is no warranty for this free software. For both users' and\r\nauthors' sake, the GPL requires that modified versions be marked as\r\nchanged, so that their problems will not be attributed erroneously to\r\nauthors of previous versions.\r\n\r\n Some devices are designed to deny users access to install or run\r\nmodified versions of the software inside them, although the manufacturer\r\ncan do so. This is fundamentally incompatible with the aim of\r\nprotecting users' freedom to change the software. The systematic\r\npattern of such abuse occurs in the area of products for individuals to\r\nuse, which is precisely where it is most unacceptable. Therefore, we\r\nhave designed this version of the GPL to prohibit the practice for those\r\nproducts. If such problems arise substantially in other domains, we\r\nstand ready to extend this provision to those domains in future versions\r\nof the GPL, as needed to protect the freedom of users.\r\n\r\n Finally, every program is threatened constantly by software patents.\r\nStates should not allow patents to restrict development and use of\r\nsoftware on general-purpose computers, but in those that do, we wish to\r\navoid the special danger that patents applied to a free program could\r\nmake it effectively proprietary. To prevent this, the GPL assures that\r\npatents cannot be used to render the program non-free.\r\n\r\n The precise terms and conditions for copying, distribution and\r\nmodification follow.\r\n\r\n TERMS AND CONDITIONS\r\n\r\n 0. Definitions.\r\n\r\n \"This License\" refers to version 3 of the GNU General Public License.\r\n\r\n \"Copyright\" also means copyright-like laws that apply to other kinds of\r\nworks, such as semiconductor masks.\r\n\r\n \"The Program\" refers to any copyrightable work licensed under this\r\nLicense. Each licensee is addressed as \"you\". \"Licensees\" and\r\n\"recipients\" may be individuals or organizations.\r\n\r\n To \"modify\" a work means to copy from or adapt all or part of the work\r\nin a fashion requiring copyright permission, other than the making of an\r\nexact copy. The resulting work is called a \"modified version\" of the\r\nearlier work or a work \"based on\" the earlier work.\r\n\r\n A \"covered work\" means either the unmodified Program or a work based\r\non the Program.\r\n\r\n To \"propagate\" a work means to do anything with it that, without\r\npermission, would make you directly or secondarily liable for\r\ninfringement under applicable copyright law, except executing it on a\r\ncomputer or modifying a private copy. Propagation includes copying,\r\ndistribution (with or without modification), making available to the\r\npublic, and in some countries other activities as well.\r\n\r\n To \"convey\" a work means any kind of propagation that enables other\r\nparties to make or receive copies. Mere interaction with a user through\r\na computer network, with no transfer of a copy, is not conveying.\r\n\r\n An interactive user interface displays \"Appropriate Legal Notices\"\r\nto the extent that it includes a convenient and prominently visible\r\nfeature that (1) displays an appropriate copyright notice, and (2)\r\ntells the user that there is no warranty for the work (except to the\r\nextent that warranties are provided), that licensees may convey the\r\nwork under this License, and how to view a copy of this License. If\r\nthe interface presents a list of user commands or options, such as a\r\nmenu, a prominent item in the list meets this criterion.\r\n\r\n 1. Source Code.\r\n\r\n The \"source code\" for a work means the preferred form of the work\r\nfor making modifications to it. \"Object code\" means any non-source\r\nform of a work.\r\n\r\n A \"Standard Interface\" means an interface that either is an official\r\nstandard defined by a recognized standards body, or, in the case of\r\ninterfaces specified for a particular programming language, one that\r\nis widely used among developers working in that language.\r\n\r\n The \"System Libraries\" of an executable work include anything, other\r\nthan the work as a whole, that (a) is included in the normal form of\r\npackaging a Major Component, but which is not part of that Major\r\nComponent, and (b) serves only to enable use of the work with that\r\nMajor Component, or to implement a Standard Interface for which an\r\nimplementation is available to the public in source code form. A\r\n\"Major Component\", in this context, means a major essential component\r\n(kernel, window system, and so on) of the specific operating system\r\n(if any) on which the executable work runs, or a compiler used to\r\nproduce the work, or an object code interpreter used to run it.\r\n\r\n The \"Corresponding Source\" for a work in object code form means all\r\nthe source code needed to generate, install, and (for an executable\r\nwork) run the object code and to modify the work, including scripts to\r\ncontrol those activities. However, it does not include the work's\r\nSystem Libraries, or general-purpose tools or generally available free\r\nprograms which are used unmodified in performing those activities but\r\nwhich are not part of the work. For example, Corresponding Source\r\nincludes interface definition files associated with source files for\r\nthe work, and the source code for shared libraries and dynamically\r\nlinked subprograms that the work is specifically designed to require,\r\nsuch as by intimate data communication or control flow between those\r\nsubprograms and other parts of the work.\r\n\r\n The Corresponding Source need not include anything that users\r\ncan regenerate automatically from other parts of the Corresponding\r\nSource.\r\n\r\n The Corresponding Source for a work in source code form is that\r\nsame work.\r\n\r\n 2. Basic Permissions.\r\n\r\n All rights granted under this License are granted for the term of\r\ncopyright on the Program, and are irrevocable provided the stated\r\nconditions are met. This License explicitly affirms your unlimited\r\npermission to run the unmodified Program. The output from running a\r\ncovered work is covered by this License only if the output, given its\r\ncontent, constitutes a covered work. This License acknowledges your\r\nrights of fair use or other equivalent, as provided by copyright law.\r\n\r\n You may make, run and propagate covered works that you do not\r\nconvey, without conditions so long as your license otherwise remains\r\nin force. You may convey covered works to others for the sole purpose\r\nof having them make modifications exclusively for you, or provide you\r\nwith facilities for running those works, provided that you comply with\r\nthe terms of this License in conveying all material for which you do\r\nnot control copyright. Those thus making or running the covered works\r\nfor you must do so exclusively on your behalf, under your direction\r\nand control, on terms that prohibit them from making any copies of\r\nyour copyrighted material outside their relationship with you.\r\n\r\n Conveying under any other circumstances is permitted solely under\r\nthe conditions stated below. Sublicensing is not allowed; section 10\r\nmakes it unnecessary.\r\n\r\n 3. Protecting Users' Legal Rights From Anti-Circumvention Law.\r\n\r\n No covered work shall be deemed part of an effective technological\r\nmeasure under any applicable law fulfilling obligations under article\r\n11 of the WIPO copyright treaty adopted on 20 December 1996, or\r\nsimilar laws prohibiting or restricting circumvention of such\r\nmeasures.\r\n\r\n When you convey a covered work, you waive any legal power to forbid\r\ncircumvention of technological measures to the extent such circumvention\r\nis effected by exercising rights under this License with respect to\r\nthe covered work, and you disclaim any intention to limit operation or\r\nmodification of the work as a means of enforcing, against the work's\r\nusers, your or third parties' legal rights to forbid circumvention of\r\ntechnological measures.\r\n\r\n 4. Conveying Verbatim Copies.\r\n\r\n You may convey verbatim copies of the Program's source code as you\r\nreceive it, in any medium, provided that you conspicuously and\r\nappropriately publish on each copy an appropriate copyright notice;\r\nkeep intact all notices stating that this License and any\r\nnon-permissive terms added in accord with section 7 apply to the code;\r\nkeep intact all notices of the absence of any warranty; and give all\r\nrecipients a copy of this License along with the Program.\r\n\r\n You may charge any price or no price for each copy that you convey,\r\nand you may offer support or warranty protection for a fee.\r\n\r\n 5. Conveying Modified Source Versions.\r\n\r\n You may convey a work based on the Program, or the modifications to\r\nproduce it from the Program, in the form of source code under the\r\nterms of section 4, provided that you also meet all of these conditions:\r\n\r\n a) The work must carry prominent notices stating that you modified\r\n it, and giving a relevant date.\r\n\r\n b) The work must carry prominent notices stating that it is\r\n released under this License and any conditions added under section\r\n 7. This requirement modifies the requirement in section 4 to\r\n \"keep intact all notices\".\r\n\r\n c) You must license the entire work, as a whole, under this\r\n License to anyone who comes into possession of a copy. This\r\n License will therefore apply, along with any applicable section 7\r\n additional terms, to the whole of the work, and all its parts,\r\n regardless of how they are packaged. This License gives no\r\n permission to license the work in any other way, but it does not\r\n invalidate such permission if you have separately received it.\r\n\r\n d) If the work has interactive user interfaces, each must display\r\n Appropriate Legal Notices; however, if the Program has interactive\r\n interfaces that do not display Appropriate Legal Notices, your\r\n work need not make them do so.\r\n\r\n A compilation of a covered work with other separate and independent\r\nworks, which are not by their nature extensions of the covered work,\r\nand which are not combined with it such as to form a larger program,\r\nin or on a volume of a storage or distribution medium, is called an\r\n\"aggregate\" if the compilation and its resulting copyright are not\r\nused to limit the access or legal rights of the compilation's users\r\nbeyond what the individual works permit. Inclusion of a covered work\r\nin an aggregate does not cause this License to apply to the other\r\nparts of the aggregate.\r\n\r\n 6. Conveying Non-Source Forms.\r\n\r\n You may convey a covered work in object code form under the terms\r\nof sections 4 and 5, provided that you also convey the\r\nmachine-readable Corresponding Source under the terms of this License,\r\nin one of these ways:\r\n\r\n a) Convey the object code in, or embodied in, a physical product\r\n (including a physical distribution medium), accompanied by the\r\n Corresponding Source fixed on a durable physical medium\r\n customarily used for software interchange.\r\n\r\n b) Convey the object code in, or embodied in, a physical product\r\n (including a physical distribution medium), accompanied by a\r\n written offer, valid for at least three years and valid for as\r\n long as you offer spare parts or customer support for that product\r\n model, to give anyone who possesses the object code either (1) a\r\n copy of the Corresponding Source for all the software in the\r\n product that is covered by this License, on a durable physical\r\n medium customarily used for software interchange, for a price no\r\n more than your reasonable cost of physically performing this\r\n conveying of source, or (2) access to copy the\r\n Corresponding Source from a network server at no charge.\r\n\r\n c) Convey individual copies of the object code with a copy of the\r\n written offer to provide the Corresponding Source. This\r\n alternative is allowed only occasionally and noncommercially, and\r\n only if you received the object code with such an offer, in accord\r\n with subsection 6b.\r\n\r\n d) Convey the object code by offering access from a designated\r\n place (gratis or for a charge), and offer equivalent access to the\r\n Corresponding Source in the same way through the same place at no\r\n further charge. You need not require recipients to copy the\r\n Corresponding Source along with the object code. If the place to\r\n copy the object code is a network server, the Corresponding Source\r\n may be on a different server (operated by you or a third party)\r\n that supports equivalent copying facilities, provided you maintain\r\n clear directions next to the object code saying where to find the\r\n Corresponding Source. Regardless of what server hosts the\r\n Corresponding Source, you remain obligated to ensure that it is\r\n available for as long as needed to satisfy these requirements.\r\n\r\n e) Convey the object code using peer-to-peer transmission, provided\r\n you inform other peers where the object code and Corresponding\r\n Source of the work are being offered to the general public at no\r\n charge under subsection 6d.\r\n\r\n A separable portion of the object code, whose source code is excluded\r\nfrom the Corresponding Source as a System Library, need not be\r\nincluded in conveying the object code work.\r\n\r\n A \"User Product\" is either (1) a \"consumer product\", which means any\r\ntangible personal property which is normally used for personal, family,\r\nor household purposes, or (2) anything designed or sold for incorporation\r\ninto a dwelling. In determining whether a product is a consumer product,\r\ndoubtful cases shall be resolved in favor of coverage. For a particular\r\nproduct received by a particular user, \"normally used\" refers to a\r\ntypical or common use of that class of product, regardless of the status\r\nof the particular user or of the way in which the particular user\r\nactually uses, or expects or is expected to use, the product. A product\r\nis a consumer product regardless of whether the product has substantial\r\ncommercial, industrial or non-consumer uses, unless such uses represent\r\nthe only significant mode of use of the product.\r\n\r\n \"Installation Information\" for a User Product means any methods,\r\nprocedures, authorization keys, or other information required to install\r\nand execute modified versions of a covered work in that User Product from\r\na modified version of its Corresponding Source. The information must\r\nsuffice to ensure that the continued functioning of the modified object\r\ncode is in no case prevented or interfered with solely because\r\nmodification has been made.\r\n\r\n If you convey an object code work under this section in, or with, or\r\nspecifically for use in, a User Product, and the conveying occurs as\r\npart of a transaction in which the right of possession and use of the\r\nUser Product is transferred to the recipient in perpetuity or for a\r\nfixed term (regardless of how the transaction is characterized), the\r\nCorresponding Source conveyed under this section must be accompanied\r\nby the Installation Information. But this requirement does not apply\r\nif neither you nor any third party retains the ability to install\r\nmodified object code on the User Product (for example, the work has\r\nbeen installed in ROM).\r\n\r\n The requirement to provide Installation Information does not include a\r\nrequirement to continue to provide support service, warranty, or updates\r\nfor a work that has been modified or installed by the recipient, or for\r\nthe User Product in which it has been modified or installed. Access to a\r\nnetwork may be denied when the modification itself materially and\r\nadversely affects the operation of the network or violates the rules and\r\nprotocols for communication across the network.\r\n\r\n Corresponding Source conveyed, and Installation Information provided,\r\nin accord with this section must be in a format that is publicly\r\ndocumented (and with an implementation available to the public in\r\nsource code form), and must require no special password or key for\r\nunpacking, reading or copying.\r\n\r\n 7. Additional Terms.\r\n\r\n \"Additional permissions\" are terms that supplement the terms of this\r\nLicense by making exceptions from one or more of its conditions.\r\nAdditional permissions that are applicable to the entire Program shall\r\nbe treated as though they were included in this License, to the extent\r\nthat they are valid under applicable law. If additional permissions\r\napply only to part of the Program, that part may be used separately\r\nunder those permissions, but the entire Program remains governed by\r\nthis License without regard to the additional permissions.\r\n\r\n When you convey a copy of a covered work, you may at your option\r\nremove any additional permissions from that copy, or from any part of\r\nit. (Additional permissions may be written to require their own\r\nremoval in certain cases when you modify the work.) You may place\r\nadditional permissions on material, added by you to a covered work,\r\nfor which you have or can give appropriate copyright permission.\r\n\r\n Notwithstanding any other provision of this License, for material you\r\nadd to a covered work, you may (if authorized by the copyright holders of\r\nthat material) supplement the terms of this License with terms:\r\n\r\n a) Disclaiming warranty or limiting liability differently from the\r\n terms of sections 15 and 16 of this License; or\r\n\r\n b) Requiring preservation of specified reasonable legal notices or\r\n author attributions in that material or in the Appropriate Legal\r\n Notices displayed by works containing it; or\r\n\r\n c) Prohibiting misrepresentation of the origin of that material, or\r\n requiring that modified versions of such material be marked in\r\n reasonable ways as different from the original version; or\r\n\r\n d) Limiting the use for publicity purposes of names of licensors or\r\n authors of the material; or\r\n\r\n e) Declining to grant rights under trademark law for use of some\r\n trade names, trademarks, or service marks; or\r\n\r\n f) Requiring indemnification of licensors and authors of that\r\n material by anyone who conveys the material (or modified versions of\r\n it) with contractual assumptions of liability to the recipient, for\r\n any liability that these contractual assumptions directly impose on\r\n those licensors and authors.\r\n\r\n All other non-permissive additional terms are considered \"further\r\nrestrictions\" within the meaning of section 10. If the Program as you\r\nreceived it, or any part of it, contains a notice stating that it is\r\ngoverned by this License along with a term that is a further\r\nrestriction, you may remove that term. If a license document contains\r\na further restriction but permits relicensing or conveying under this\r\nLicense, you may add to a covered work material governed by the terms\r\nof that license document, provided that the further restriction does\r\nnot survive such relicensing or conveying.\r\n\r\n If you add terms to a covered work in accord with this section, you\r\nmust place, in the relevant source files, a statement of the\r\nadditional terms that apply to those files, or a notice indicating\r\nwhere to find the applicable terms.\r\n\r\n Additional terms, permissive or non-permissive, may be stated in the\r\nform of a separately written license, or stated as exceptions;\r\nthe above requirements apply either way.\r\n\r\n 8. Termination.\r\n\r\n You may not propagate or modify a covered work except as expressly\r\nprovided under this License. Any attempt otherwise to propagate or\r\nmodify it is void, and will automatically terminate your rights under\r\nthis License (including any patent licenses granted under the third\r\nparagraph of section 11).\r\n\r\n However, if you cease all violation of this License, then your\r\nlicense from a particular copyright holder is reinstated (a)\r\nprovisionally, unless and until the copyright holder explicitly and\r\nfinally terminates your license, and (b) permanently, if the copyright\r\nholder fails to notify you of the violation by some reasonable means\r\nprior to 60 days after the cessation.\r\n\r\n Moreover, your license from a particular copyright holder is\r\nreinstated permanently if the copyright holder notifies you of the\r\nviolation by some reasonable means, this is the first time you have\r\nreceived notice of violation of this License (for any work) from that\r\ncopyright holder, and you cure the violation prior to 30 days after\r\nyour receipt of the notice.\r\n\r\n Termination of your rights under this section does not terminate the\r\nlicenses of parties who have received copies or rights from you under\r\nthis License. If your rights have been terminated and not permanently\r\nreinstated, you do not qualify to receive new licenses for the same\r\nmaterial under section 10.\r\n\r\n 9. Acceptance Not Required for Having Copies.\r\n\r\n You are not required to accept this License in order to receive or\r\nrun a copy of the Program. Ancillary propagation of a covered work\r\noccurring solely as a consequence of using peer-to-peer transmission\r\nto receive a copy likewise does not require acceptance. However,\r\nnothing other than this License grants you permission to propagate or\r\nmodify any covered work. These actions infringe copyright if you do\r\nnot accept this License. Therefore, by modifying or propagating a\r\ncovered work, you indicate your acceptance of this License to do so.\r\n\r\n 10. Automatic Licensing of Downstream Recipients.\r\n\r\n Each time you convey a covered work, the recipient automatically\r\nreceives a license from the original licensors, to run, modify and\r\npropagate that work, subject to this License. You are not responsible\r\nfor enforcing compliance by third parties with this License.\r\n\r\n An \"entity transaction\" is a transaction transferring control of an\r\norganization, or substantially all assets of one, or subdividing an\r\norganization, or merging organizations. If propagation of a covered\r\nwork results from an entity transaction, each party to that\r\ntransaction who receives a copy of the work also receives whatever\r\nlicenses to the work the party's predecessor in interest had or could\r\ngive under the previous paragraph, plus a right to possession of the\r\nCorresponding Source of the work from the predecessor in interest, if\r\nthe predecessor has it or can get it with reasonable efforts.\r\n\r\n You may not impose any further restrictions on the exercise of the\r\nrights granted or affirmed under this License. For example, you may\r\nnot impose a license fee, royalty, or other charge for exercise of\r\nrights granted under this License, and you may not initiate litigation\r\n(including a cross-claim or counterclaim in a lawsuit) alleging that\r\nany patent claim is infringed by making, using, selling, offering for\r\nsale, or importing the Program or any portion of it.\r\n\r\n 11. Patents.\r\n\r\n A \"contributor\" is a copyright holder who authorizes use under this\r\nLicense of the Program or a work on which the Program is based. The\r\nwork thus licensed is called the contributor's \"contributor version\".\r\n\r\n A contributor's \"essential patent claims\" are all patent claims\r\nowned or controlled by the contributor, whether already acquired or\r\nhereafter acquired, that would be infringed by some manner, permitted\r\nby this License, of making, using, or selling its contributor version,\r\nbut do not include claims that would be infringed only as a\r\nconsequence of further modification of the contributor version. For\r\npurposes of this definition, \"control\" includes the right to grant\r\npatent sublicenses in a manner consistent with the requirements of\r\nthis License.\r\n\r\n Each contributor grants you a non-exclusive, worldwide, royalty-free\r\npatent license under the contributor's essential patent claims, to\r\nmake, use, sell, offer for sale, import and otherwise run, modify and\r\npropagate the contents of its contributor version.\r\n\r\n In the following three paragraphs, a \"patent license\" is any express\r\nagreement or commitment, however denominated, not to enforce a patent\r\n(such as an express permission to practice a patent or covenant not to\r\nsue for patent infringement). To \"grant\" such a patent license to a\r\nparty means to make such an agreement or commitment not to enforce a\r\npatent against the party.\r\n\r\n If you convey a covered work, knowingly relying on a patent license,\r\nand the Corresponding Source of the work is not available for anyone\r\nto copy, free of charge and under the terms of this License, through a\r\npublicly available network server or other readily accessible means,\r\nthen you must either (1) cause the Corresponding Source to be so\r\navailable, or (2) arrange to deprive yourself of the benefit of the\r\npatent license for this particular work, or (3) arrange, in a manner\r\nconsistent with the requirements of this License, to extend the patent\r\nlicense to downstream recipients. \"Knowingly relying\" means you have\r\nactual knowledge that, but for the patent license, your conveying the\r\ncovered work in a country, or your recipient's use of the covered work\r\nin a country, would infringe one or more identifiable patents in that\r\ncountry that you have reason to believe are valid.\r\n\r\n If, pursuant to or in connection with a single transaction or\r\narrangement, you convey, or propagate by procuring conveyance of, a\r\ncovered work, and grant a patent license to some of the parties\r\nreceiving the covered work authorizing them to use, propagate, modify\r\nor convey a specific copy of the covered work, then the patent license\r\nyou grant is automatically extended to all recipients of the covered\r\nwork and works based on it.\r\n\r\n A patent license is \"discriminatory\" if it does not include within\r\nthe scope of its coverage, prohibits the exercise of, or is\r\nconditioned on the non-exercise of one or more of the rights that are\r\nspecifically granted under this License. You may not convey a covered\r\nwork if you are a party to an arrangement with a third party that is\r\nin the business of distributing software, under which you make payment\r\nto the third party based on the extent of your activity of conveying\r\nthe work, and under which the third party grants, to any of the\r\nparties who would receive the covered work from you, a discriminatory\r\npatent license (a) in connection with copies of the covered work\r\nconveyed by you (or copies made from those copies), or (b) primarily\r\nfor and in connection with specific products or compilations that\r\ncontain the covered work, unless you entered into that arrangement,\r\nor that patent license was granted, prior to 28 March 2007.\r\n\r\n Nothing in this License shall be construed as excluding or limiting\r\nany implied license or other defenses to infringement that may\r\notherwise be available to you under applicable patent law.\r\n\r\n 12. No Surrender of Others' Freedom.\r\n\r\n If conditions are imposed on you (whether by court order, agreement or\r\notherwise) that contradict the conditions of this License, they do not\r\nexcuse you from the conditions of this License. If you cannot convey a\r\ncovered work so as to satisfy simultaneously your obligations under this\r\nLicense and any other pertinent obligations, then as a consequence you may\r\nnot convey it at all. For example, if you agree to terms that obligate you\r\nto collect a royalty for further conveying from those to whom you convey\r\nthe Program, the only way you could satisfy both those terms and this\r\nLicense would be to refrain entirely from conveying the Program.\r\n\r\n 13. Use with the GNU Affero General Public License.\r\n\r\n Notwithstanding any other provision of this License, you have\r\npermission to link or combine any covered work with a work licensed\r\nunder version 3 of the GNU Affero General Public License into a single\r\ncombined work, and to convey the resulting work. The terms of this\r\nLicense will continue to apply to the part which is the covered work,\r\nbut the special requirements of the GNU Affero General Public License,\r\nsection 13, concerning interaction through a network will apply to the\r\ncombination as such.\r\n\r\n 14. Revised Versions of this License.\r\n\r\n The Free Software Foundation may publish revised and/or new versions of\r\nthe GNU General Public License from time to time. Such new versions will\r\nbe similar in spirit to the present version, but may differ in detail to\r\naddress new problems or concerns.\r\n\r\n Each version is given a distinguishing version number. If the\r\nProgram specifies that a certain numbered version of the GNU General\r\nPublic License \"or any later version\" applies to it, you have the\r\noption of following the terms and conditions either of that numbered\r\nversion or of any later version published by the Free Software\r\nFoundation. If the Program does not specify a version number of the\r\nGNU General Public License, you may choose any version ever published\r\nby the Free Software Foundation.\r\n\r\n If the Program specifies that a proxy can decide which future\r\nversions of the GNU General Public License can be used, that proxy's\r\npublic statement of acceptance of a version permanently authorizes you\r\nto choose that version for the Program.\r\n\r\n Later license versions may give you additional or different\r\npermissions. However, no additional obligations are imposed on any\r\nauthor or copyright holder as a result of your choosing to follow a\r\nlater version.\r\n\r\n 15. Disclaimer of Warranty.\r\n\r\n THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\r\nAPPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\r\nHOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\r\nOF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\r\nTHE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\r\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\r\nIS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\r\nALL NECESSARY SERVICING, REPAIR OR CORRECTION.\r\n\r\n 16. Limitation of Liability.\r\n\r\n IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\r\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\r\nTHE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY\r\nGENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE\r\nUSE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF\r\nDATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD\r\nPARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),\r\nEVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF\r\nSUCH DAMAGES.\r\n\r\n 17. Interpretation of Sections 15 and 16.\r\n\r\n If the disclaimer of warranty and limitation of liability provided\r\nabove cannot be given local legal effect according to their terms,\r\nreviewing courts shall apply local law that most closely approximates\r\nan absolute waiver of all civil liability in connection with the\r\nProgram, unless a warranty or assumption of liability accompanies a\r\ncopy of the Program in return for a fee.\r\n\r\n END OF TERMS AND CONDITIONS\r\n\r\n How to Apply These Terms to Your New Programs\r\n\r\n If you develop a new program, and you want it to be of the greatest\r\npossible use to the public, the best way to achieve this is to make it\r\nfree software which everyone can redistribute and change under these terms.\r\n\r\n To do so, attach the following notices to the program. It is safest\r\nto attach them to the start of each source file to most effectively\r\nstate the exclusion of warranty; and each file should have at least\r\nthe \"copyright\" line and a pointer to where the full notice is found.\r\n\r\n \r\n Copyright (C) \r\n\r\n This program is free software: you can redistribute it and/or modify\r\n it under the terms of the GNU General Public License as published by\r\n the Free Software Foundation, either version 3 of the License, or\r\n (at your option) any later version.\r\n\r\n This program is distributed in the hope that it will be useful,\r\n but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r\n GNU General Public License for more details.\r\n\r\n You should have received a copy of the GNU General Public License\r\n along with this program. If not, see .\r\n\r\nAlso add information on how to contact you by electronic and paper mail.\r\n\r\n If the program does terminal interaction, make it output a short\r\nnotice like this when it starts in an interactive mode:\r\n\r\n Copyright (C) \r\n This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\r\n This is free software, and you are welcome to redistribute it\r\n under certain conditions; type `show c' for details.\r\n\r\nThe hypothetical commands `show w' and `show c' should show the appropriate\r\nparts of the General Public License. Of course, your program's commands\r\nmight be different; for a GUI interface, you would use an \"about box\".\r\n\r\n You should also get your employer (if you work as a programmer) or school,\r\nif any, to sign a \"copyright disclaimer\" for the program, if necessary.\r\nFor more information on this, and how to apply and follow the GNU GPL, see\r\n.\r\n\r\n The GNU General Public License does not permit incorporating your program\r\ninto proprietary programs. If your program is a subroutine library, you\r\nmay consider it more useful to permit linking proprietary applications with\r\nthe library. If this is what you want to do, use the GNU Lesser General\r\nPublic License instead of this License. But first, please read\r\n.\r\n"
},
{
"path": "Makefile",
"content": "#---------------------------------------------------------------------------------\r\n.SUFFIXES:\r\n#---------------------------------------------------------------------------------\r\n\r\nifeq ($(strip $(DEVKITPRO)),)\r\n$(error \"Please set DEVKITPRO in your environment. export DEVKITPRO=/devkitpro\")\r\nendif\r\n\r\nTOPDIR ?= $(CURDIR)\r\ninclude $(DEVKITPRO)/libnx/switch_rules\r\n\r\n#---------------------------------------------------------------------------------\r\n# TARGET is the name of the output\r\n# BUILD is the directory where object files & intermediate files will be placed\r\n# SOURCES is a list of directories containing source code\r\n# DATA is a list of directories containing data files\r\n# INCLUDES is a list of directories containing header files\r\n# ROMFS is the directory containing data to be added to RomFS, relative to the Makefile (Optional)\r\n#\r\n# NO_ICON: if set to anything, do not use icon.\r\n# NO_NACP: if set to anything, no .nacp file is generated.\r\n# APP_TITLE is the name of the app stored in the .nacp file (Optional)\r\n# APP_AUTHOR is the author of the app stored in the .nacp file (Optional)\r\n# APP_VERSION is the version of the app stored in the .nacp file (Optional)\r\n# APP_TITLEID is the titleID of the app stored in the .nacp file (Optional)\r\n# ICON is the filename of the icon (.jpg), relative to the project folder.\r\n# If not set, it attempts to use one of the following (in this order):\r\n# - .jpg\r\n# - icon.jpg\r\n# - /default_icon.jpg\r\n#\r\n# CONFIG_JSON is the filename of the NPDM config file (.json), relative to the project folder.\r\n# If not set, it attempts to use one of the following (in this order):\r\n# - .json\r\n# - config.json\r\n# If a JSON file is provided or autodetected, an ExeFS PFS0 (.nsp) is built instead\r\n# of a homebrew executable (.nro). This is intended to be used for sysmodules.\r\n# NACP building is skipped as well.\r\n#---------------------------------------------------------------------------------\r\nTARGET\t\t:=\t$(notdir $(CURDIR))\r\nBUILD\t\t:=\tbuild\r\nSOURCES\t\t:=\tsource libs/minizip/source\r\nDATA\t\t:=\tdata \r\nINCLUDES\t:=\tinclude libs/minizip/include\r\n#ROMFS\t\t:=\tromfs\r\nAPP_TITLE := Cheats Updater\r\nAPP_AUTHOR := HamletDuFromage & Acta\r\nAPP_VERSION := 1.2.1\r\n\r\n#---------------------------------------------------------------------------------\r\n# options for code generation\r\n#---------------------------------------------------------------------------------\r\nARCH\t:=\t-march=armv8-a+crc+crypto -mtune=cortex-a57 -mtp=soft -fPIE\r\n\r\nCFLAGS\t:=\t-g -Wall -O2 -ffunction-sections \\\r\n\t\t\t$(ARCH) $(DEFINES)\r\n\r\nCFLAGS\t+=\t$(INCLUDE) -D__SWITCH__\r\n\r\nCXXFLAGS\t:= $(CFLAGS) -fexceptions -std=gnu++17 -Wno-reorder\r\n\r\n\r\nASFLAGS\t:=\t-g $(ARCH)\r\nLDFLAGS\t=\t-specs=$(DEVKITPRO)/libnx/switch.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)\r\n\r\nLIBS\t:= -lcurl -lnx -lz -lmbedtls -lmbedx509 -lmbedcrypto -lstdc++fs `freetype-config --libs`\r\n\r\n#---------------------------------------------------------------------------------\r\n# list of directories containing libraries, this must be the top level containing\r\n# include and lib\r\n#---------------------------------------------------------------------------------\r\nLIBDIRS\t:= $(PORTLIBS) $(LIBNX)\r\n\r\n\r\n#---------------------------------------------------------------------------------\r\n# no real need to edit anything past this point unless you need to add additional\r\n# rules for different file extensions\r\n#---------------------------------------------------------------------------------\r\nifneq ($(BUILD),$(notdir $(CURDIR)))\r\n#---------------------------------------------------------------------------------\r\n\r\nexport OUTPUT\t:=\t$(CURDIR)/$(TARGET)\r\nexport TOPDIR\t:=\t$(CURDIR)\r\n\r\nexport VPATH\t:=\t$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \\\r\n\t\t\t$(foreach dir,$(DATA),$(CURDIR)/$(dir))\r\n\r\nexport DEPSDIR\t:=\t$(CURDIR)/$(BUILD)\r\n\r\nCFILES\t\t:=\t$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))\r\nCPPFILES\t:=\t$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))\r\nSFILES\t\t:=\t$(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))\r\nBINFILES\t:=\t$(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))\r\n\r\n#---------------------------------------------------------------------------------\r\n# use CXX for linking C++ projects, CC for standard C\r\n#---------------------------------------------------------------------------------\r\nifeq ($(strip $(CPPFILES)),)\r\n#---------------------------------------------------------------------------------\r\n\texport LD\t:=\t$(CC)\r\n#---------------------------------------------------------------------------------\r\nelse\r\n#---------------------------------------------------------------------------------\r\n\texport LD\t:=\t$(CXX)\r\n#---------------------------------------------------------------------------------\r\nendif\r\n#---------------------------------------------------------------------------------\r\n\r\nexport OFILES_BIN\t:=\t$(addsuffix .o,$(BINFILES))\r\nexport OFILES_SRC\t:=\t$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)\r\nexport OFILES \t:=\t$(OFILES_BIN) $(OFILES_SRC)\r\nexport HFILES_BIN\t:=\t$(addsuffix .h,$(subst .,_,$(BINFILES)))\r\n\r\nexport INCLUDE\t:=\t$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \\\r\n\t\t\t$(foreach dir,$(LIBDIRS),-I$(dir)/include) \\\r\n\t\t\t-I$(CURDIR)/$(BUILD)\r\n\r\nexport LIBPATHS\t:=\t$(foreach dir,$(LIBDIRS),-L$(dir)/lib)\r\n\r\nifeq ($(strip $(CONFIG_JSON)),)\r\n\tjsons := $(wildcard *.json)\r\n\tifneq (,$(findstring $(TARGET).json,$(jsons)))\r\n\t\texport APP_JSON := $(TOPDIR)/$(TARGET).json\r\n\telse\r\n\t\tifneq (,$(findstring config.json,$(jsons)))\r\n\t\t\texport APP_JSON := $(TOPDIR)/config.json\r\n\t\tendif\r\n\tendif\r\nelse\r\n\texport APP_JSON := $(TOPDIR)/$(CONFIG_JSON)\r\nendif\r\n\r\nifeq ($(strip $(ICON)),)\r\n\ticons := $(wildcard *.jpg)\r\n\tifneq (,$(findstring $(TARGET).jpg,$(icons)))\r\n\t\texport APP_ICON := $(TOPDIR)/$(TARGET).jpg\r\n\telse\r\n\t\tifneq (,$(findstring icon.jpg,$(icons)))\r\n\t\t\texport APP_ICON := $(TOPDIR)/icon.jpg\r\n\t\tendif\r\n\tendif\r\nelse\r\n\texport APP_ICON := $(TOPDIR)/$(ICON)\r\nendif\r\n\r\nifeq ($(strip $(NO_ICON)),)\r\n\texport NROFLAGS += --icon=$(APP_ICON)\r\nendif\r\n\r\nifeq ($(strip $(NO_NACP)),)\r\n\texport NROFLAGS += --nacp=$(CURDIR)/$(TARGET).nacp\r\nendif\r\n\r\nifneq ($(APP_TITLEID),)\r\n\texport NACPFLAGS += --titleid=$(APP_TITLEID)\r\nendif\r\n\r\nifneq ($(ROMFS),)\r\n\texport NROFLAGS += --romfsdir=$(CURDIR)/$(ROMFS)\r\nendif\r\n\r\n.PHONY: $(BUILD) clean all\r\n\r\n#---------------------------------------------------------------------------------\r\nall: $(BUILD)\r\n\r\n$(BUILD):\r\n\t@[ -d $@ ] || mkdir -p $@\r\n\t@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile\r\n\r\n#---------------------------------------------------------------------------------\r\nclean:\r\n\t@echo clean ...\r\nifeq ($(strip $(APP_JSON)),)\r\n\t@rm -fr $(BUILD) $(TARGET).nro $(TARGET).nacp $(TARGET).elf\r\nelse\r\n\t@rm -fr $(BUILD) $(TARGET).nsp $(TARGET).nso $(TARGET).npdm $(TARGET).elf\r\nendif\r\n\r\n\r\n#---------------------------------------------------------------------------------\r\nelse\r\n.PHONY:\tall\r\n\r\nDEPENDS\t:=\t$(OFILES:.o=.d)\r\n\r\n#---------------------------------------------------------------------------------\r\n# main targets\r\n#---------------------------------------------------------------------------------\r\nifeq ($(strip $(APP_JSON)),)\r\n\r\nall\t:\t$(OUTPUT).nro\r\n\r\nifeq ($(strip $(NO_NACP)),)\r\n$(OUTPUT).nro\t:\t$(OUTPUT).elf $(OUTPUT).nacp\r\nelse\r\n$(OUTPUT).nro\t:\t$(OUTPUT).elf\r\nendif\r\n\r\nelse\r\n\r\nall\t:\t$(OUTPUT).nsp\r\n\r\n$(OUTPUT).nsp\t:\t$(OUTPUT).nso $(OUTPUT).npdm\r\n\r\n$(OUTPUT).nso\t:\t$(OUTPUT).elf\r\n\r\nendif\r\n\r\n$(OUTPUT).elf\t:\t$(OFILES)\r\n\r\n$(OFILES_SRC)\t: $(HFILES_BIN)\r\n\r\n#---------------------------------------------------------------------------------\r\n# you need a rule like this for each extension you use as binary data\r\n#---------------------------------------------------------------------------------\r\n%.bin.o\t%_bin.h :\t%.bin\r\n#---------------------------------------------------------------------------------\r\n\t@echo $(notdir $<)\r\n\t@$(bin2o)\r\n\r\n-include $(DEPENDS)\r\n\r\n#---------------------------------------------------------------------------------------\r\nendif\r\n#---------------------------------------------------------------------------------------\r\n"
},
{
"path": "README.md",
"content": "# NOT SUPPORTED ANYMORE, USE THIS INSTEAD: https://github.com/HamletDuFromage/AIO-switch-updater\r\nWhile this app will still work, I recommend using AIO-switch-updater which adds QOL improvements chosing which cheats to not update with a GUI\r\n\r\n# switch-cheats-updater\r\n\r\n![](\"https://user-images.githubusercontent.com/61667930/78696328-916c2a00-78ff-11ea-95e4-f104e8428e64.jpg\"\\)
\r\n![\"GitHub](\"https://img.shields.io/github/downloads/HamletDuFromage/switch-cheats-updater/total\")
\r\n
\r\n\r\nA Nintendo Switch homebrew app to automatically update your cheat files for your installed games, gamecarts and XCIs. Supports Atmosphere, ReiNX and SXOS.\r\n\r\n\r\nFetches the latest cheats from the [gbatemp general thread](https://gbatemp.net/download/cheat-codes-sxos-and-ams-main-cheat-file-updated.36311/updates) through [my mirror](https://github.com/HamletDuFromage/switch-cheats-db/releases) (updates once a day)\r\n\r\n## Blacklist titles\r\nBy default, this homebrew will overwrite the existing cheats. If you have your own cheat files that you'd like to keep as is, you may add the title IDs of the corresponding games, one ID per line, to `/config/cheats-updater/exclude.txt`. Use http://tinfoil.io/title to find the title ID of a game.\r\n\r\n## How to install\r\nCopy the `switch-cheats-updater/` directory to `/switch/` in your sdcard\r\n\r\n## Screenshots\r\n\r\n\r\n\r\n## Thanks\r\n- [wilsam239 (Acta)](https://github.com/wilsam239) for his [significant QOL contribtions](https://github.com/HamletDuFromage/switch-cheats-updater/pull/3)\r\n\r\n- [ITotalJustice](https://github.com/ITotalJustice) for his download functions\r\n\r\n- The AtlasNX discord for helping me various with libnx questions in the past few weeks\r\n"
},
{
"path": "include/download.hpp",
"content": "#ifndef _DOWNLOAD_H_\r\n#define _DOWNLOAD_H_\r\n\r\n#define ON 1\r\n#define OFF 0\r\n\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n\r\nbool downloadFile(const char *url, const char *output, int api);\r\n\r\nstd::string fetchVersion(const char *url, const char *range);\r\n\r\n#endif"
},
{
"path": "include/extract.hpp",
"content": "#ifndef EXTRACT_HPP\r\n#define EXTRACT_HPP\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n\r\n#include \r\n#include \"title.h\"\r\n#include \"titles.hpp\"\r\n\r\n#define CONFIG_PATH \"/config/cheats-updater/\"\r\n#define CONTENTS_PATH \"contents/\"\r\n#define TITLES_PATH \"titles/\"\r\n#define AMS_PATH \"/atmosphere/\"\r\n#define SXOS_PATH \"/sxos/\"\r\n#define REINX_PATH \"/ReiNX/\"\r\n\r\nenum CFW{\r\n ams,\r\n rnx,\r\n sxos,\r\n};\r\n\r\nstd::vector getInstalledTitles(std::vector storageId);\r\n\r\nstd::vector getInstalledTitlesNs();\r\n\r\nstd::string formatApplicationId(u64 ApplicationId);\r\n\r\nstd::vector<Title> excludeTitles(const char* path, std::vector<Title> listedTitles);\r\n\r\nint extractCheats(std::string zipPath, std::vector<Title> titles, int cfw, bool credits);\r\n\r\nint removeCheats(int cfw);\r\n\r\nbool caselessCompare (const std::string& a, const std::string& b);\r\n\r\nstatic constexpr u32 MaxTitleCount = 64000;\r\n\r\n#endif\r\n\r\n"
},
{
"path": "include/title.h",
"content": "#include <iostream>\r\n\r\n#ifndef TITLE\r\n#define TITLE\r\n\r\n/* Defines the Title structure\r\n id: the title ID\r\n name: the title Name\r\n\r\n This overloads operators too, so that sorting and comparison can be done.\r\n*/\r\nstruct Title {\r\n std::string id;\r\n std::string name;\r\n bool operator ==(const Title&x) const {\r\n return id == x.id;\r\n }\r\n\r\n bool operator <(const Title&x) const {\r\n return id < x.id;\r\n }\r\n};\r\n\r\n#endif\r\n"
},
{
"path": "include/titles.hpp",
"content": "#ifndef TITLES_HPP\r\n#define TITLES_HPP\r\n\r\n#define UPDATED_TITLES_PATH \"/config/cheats-updater/updated.dat\"\r\n\r\n#include <iostream>\r\n#include <fstream>\r\n#include <string>\r\n#include <vector>\r\n#include <switch.h>\r\n\r\n#include \"title.h\"\r\n\r\nvoid outputUpdatedTitles();\r\n\r\nvoid writeTitlesToFile(std::vector<Title> titles);\r\n\r\nstd::vector<Title> readTitlesFromFile();\r\n\r\nvoid outputUpdatedTitles();\r\n\r\nvoid printTitles(std::vector<Title> titles);\r\n\r\n#endif"
},
{
"path": "libs/minizip/include/CDirEntry.h",
"content": "// Copyright (C) 2008 by Pedro Mendes, Virginia Tech Intellectual\r\n// Properties, Inc., EML Research, gGmbH, University of Heidelberg,\r\n// and The University of Manchester.\r\n// All rights reserved.\r\n\r\n// Copyright (C) 2001 - 2007 by Pedro Mendes, Virginia Tech Intellectual\r\n// Properties, Inc. and EML Research, gGmbH.\r\n// All rights reserved.\r\n\r\n#ifndef ZIPPER_CDirEntry\r\n#define ZIPPER_CDirEntry\r\n\r\n#include <string>\r\n#include <vector>\r\n\r\nnamespace zipper\r\n{\r\n /**\r\n * This class provides an OS independent interface to directory entries\r\n * such as files and directories.\r\n */\r\n class CDirEntry\r\n {\r\n public:\r\n /**\r\n * The character used to separate directory entries.\r\n */\r\n static const std::string Separator;\r\n\r\n /**\r\n * Check whether the directory entry specified by 'path' is\r\n * a file.\r\n * @param const std::string & path\r\n * @return bool isFile\r\n */\r\n static bool isFile(const std::string & path);\r\n\r\n /**\r\n * Check whether the directory entry specified by 'path' is\r\n * is a directory.\r\n * @param const std::string & path\r\n * @return bool isDir\r\n */\r\n static bool isDir(const std::string & path);\r\n\r\n /**\r\n * Check whether the directory entry specified by 'path' exists.\r\n * @param const std::string & path\r\n * @return bool exist\r\n */\r\n static bool exist(const std::string & path);\r\n\r\n /**\r\n * Check whether the directory entry specified by 'path' is\r\n * is readable.\r\n * @param const std::string & path\r\n * @return bool isReadable\r\n */\r\n static bool isReadable(const std::string & path);\r\n\r\n /**\r\n * Check whether the directory entry specified by 'path' is\r\n * writable.\r\n * @param const std::string & path\r\n * @return bool isWritable\r\n */\r\n static bool isWritable(const std::string & path);\r\n\r\n /**\r\n * Returns the base name, i.e., the directory path and the\r\n * the suffix are removed from 'path'.\r\n * @param const std::string & path\r\n * @return std::string baseName\r\n */\r\n static std::string baseName(const std::string & path);\r\n\r\n /**\r\n * Returns the file name, i.e., the directory path is removed from 'path'.\r\n * @param const std::string & path\r\n * @return std::string fileName\r\n */\r\n static std::string fileName(const std::string & path);\r\n\r\n /**\r\n * Returns the directory path to the parent directoryu, i.e.,\r\n * the file name or directory name are removed from 'path'.\r\n * @param const std::string & path\r\n * @return std::string dirName\r\n */\r\n static std::string dirName(const std::string & path);\r\n\r\n /**\r\n * Returns the suffix, i.e., the directory path and the\r\n * the base name are removed from 'path'.\r\n * @param const std::string & path\r\n * @return std::string basename\r\n */\r\n static std::string suffix(const std::string & path);\r\n\r\n /**\r\n * Create the directory 'dir' in the parent directory 'parent'.\r\n * @param const std::string & dir\r\n * @param const std::string & parent (Default: current working directory)\r\n * @return bool success\r\n */\r\n static bool createDir(const std::string & dir,\r\n const std::string & parent = \"\");\r\n\r\n /**\r\n * Create a name for a temporary directory entry. The directory entry\r\n * will be located in the directory given\r\n * @param const std::string & dir\r\n * @param const std::string & suffix\r\n * @return std::string tmpName\r\n */\r\n static std::string createTmpName(const std::string & dir,\r\n const std::string & suffix);\r\n\r\n /**\r\n * Move a file from. If to is the directory the filename of from is\r\n * appended.\r\n * @param const std::string & from\r\n * @param const std::string & to\r\n * @return bool success\r\n */\r\n static bool move(const std::string & from,\r\n const std::string & to);\r\n\r\n /**\r\n * Removes a file or directory specified by path.\r\n * @param const std::string & path\r\n * @return bool success\r\n */\r\n static bool remove(const std::string & path);\r\n\r\n /**\r\n * Remove files or directories matching the pattern in directory dir.\r\n * @param const std::string & pattern\r\n * @param const std::string & dir\r\n * @return bool success\r\n */\r\n static bool removeFiles(const std::string & pattern,\r\n const std::string & dir);\r\n\r\n /**\r\n * Compiles the pattern to a patternList. Valid wildcards in the pattern are:\r\n * '*' matches any number of characters and '?' matches exactly one character.\r\n * @param const std::string & pattern\r\n * @return std::vector< std::string > patternList\r\n */\r\n static std::vector< std::string > compilePattern(const std::string & pattern);\r\n\r\n /**\r\n * Compare the name against the pattern list and returns whether the\r\n * name matches. The patternList can be created from a pattern by the\r\n * compilePattern method.\r\n * @param const std::string & name\r\n * @param const std::vector< std::string > & patternList\r\n * @return bool match\r\n */\r\n static bool match(const std::string & name,\r\n const std::vector< std::string > & patternList);\r\n\r\n /**\r\n * Checks whether the given path is relative\r\n * @return bool isRelative\r\n */\r\n static bool isRelativePath(const std::string & path);\r\n\r\n /**\r\n * Makes the absolute path relative to the path given in relativeTo\r\n * @param std::string & absolutePath\r\n * @param const std::string & relativeTo\r\n * @return bool success\r\n */\r\n static bool makePathRelative(std::string & absolutePath,\r\n const std::string & relativeTo);\r\n\r\n /**\r\n * Makes the relative path absolute to the path given in absoluteTo\r\n * @param std::string & relativePath\r\n * @param const std::string & absoluteTo\r\n * @return bool success\r\n */\r\n static bool makePathAbsolute(std::string & relativePath,\r\n const std::string & absoluteTo);\r\n\r\n /**\r\n * This method normalizes the path, i.e.,\r\n * it converts all '\\' to '/' (only on WIN32)\r\n * and collapses '^./' to '^', '/./' to '/', and '[^/]+/../' to '/'\r\n * @param const std::string & path\r\n * @return std::string normalizedPath\r\n */\r\n static std::string normalize(const std::string & path);\r\n\r\n private:\r\n /**\r\n * This private methods checks whether the active section matches the\r\n * specified patter. The section is automatically advanced to allow\r\n * repeated calls. On the first call 'at' must be 0. The parameters\r\n * 'at' and 'after' must not be changed outside this method.\r\n * @param const std::string & name\r\n * @param const std::string pattern\r\n * @param std::string::size_type & at\r\n * @param std::string::size_type & after\r\n * @return bool match\r\n */\r\n static bool matchInternal(const std::string & name,\r\n const std::string pattern,\r\n std::string::size_type & at,\r\n std::string::size_type & after);\r\n };\r\n}\r\n#endif // ZIPPER_CDirEntry\r\n"
},
{
"path": "libs/minizip/include/crypt.h",
"content": "/* crypt.h -- base code for traditional PKWARE encryption\r\n Version 1.01e, February 12th, 2005\r\n\r\n Copyright (C) 1998-2005 Gilles Vollant\r\n Modifications for Info-ZIP crypting\r\n Copyright (C) 2003 Terry Thorsen\r\n\r\n This code is a modified version of crypting code in Info-ZIP distribution\r\n\r\n Copyright (C) 1990-2000 Info-ZIP. All rights reserved.\r\n\r\n See the Info-ZIP LICENSE file version 2000-Apr-09 or later for terms of use\r\n which also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html\r\n\r\n The encryption/decryption parts of this source code (as opposed to the\r\n non-echoing password parts) were originally written in Europe. The\r\n whole source package can be freely distributed, including from the USA.\r\n (Prior to January 2000, re-export from the US was a violation of US law.)\r\n\r\n This encryption code is a direct transcription of the algorithm from\r\n Roger Schlafly, described by Phil Katz in the file appnote.txt. This\r\n file (appnote.txt) is distributed with the PKZIP program (even in the\r\n version without encryption capabilities).\r\n\r\n If you don't need crypting in your application, just define symbols\r\n NOCRYPT and NOUNCRYPT.\r\n*/\r\n\r\n#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))\r\n\r\n/***********************************************************************\r\n * Return the next byte in the pseudo-random sequence\r\n */\r\nstatic int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)\r\n{\r\n unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an\r\n * unpredictable manner on 16-bit systems; not a problem\r\n * with any known compiler so far, though */\r\n\r\n temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;\r\n return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);\r\n}\r\n\r\n/***********************************************************************\r\n * Update the encryption keys with the next byte of plain text\r\n */\r\nstatic int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)\r\n{\r\n (*(pkeys+0)) = CRC32((*(pkeys+0)), c);\r\n (*(pkeys+1)) += (*(pkeys+0)) & 0xff;\r\n (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;\r\n {\r\n register int keyshift = (int)((*(pkeys+1)) >> 24);\r\n (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);\r\n }\r\n return c;\r\n}\r\n\r\n\r\n/***********************************************************************\r\n * Initialize the encryption keys and the random header according to\r\n * the given password.\r\n */\r\nstatic void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)\r\n{\r\n *(pkeys+0) = 305419896L;\r\n *(pkeys+1) = 591751049L;\r\n *(pkeys+2) = 878082192L;\r\n while (*passwd != 0) {\r\n update_keys(pkeys,pcrc_32_tab,(int)*passwd);\r\n passwd++;\r\n }\r\n}\r\n\r\n#define zdecode(pkeys,pcrc_32_tab,c) \\\r\n (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))\r\n\r\n#define zencode(pkeys,pcrc_32_tab,c,t) \\\r\n (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))\r\n\r\n#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED\r\n\r\n#define RAND_HEAD_LEN 12\r\n /* \"last resort\" source for second part of crypt seed pattern */\r\n# ifndef ZCR_SEED2\r\n# define ZCR_SEED2 3141592654UL /* use PI as default pattern */\r\n# endif\r\n\r\nstatic int crypthead(const char* passwd, /* password string */\r\n unsigned char* buf, /* where to write header */\r\n int bufSize,\r\n unsigned long* pkeys,\r\n const unsigned long* pcrc_32_tab,\r\n unsigned long crcForCrypting)\r\n{\r\n int n; /* index in random header */\r\n int t; /* temporary */\r\n int c; /* random byte */\r\n unsigned char header[RAND_HEAD_LEN-2]; /* random header */\r\n static unsigned calls = 0; /* ensure different random header each time */\r\n\r\n if (bufSize<RAND_HEAD_LEN)\r\n return 0;\r\n\r\n /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the\r\n * output of rand() to get less predictability, since rand() is\r\n * often poorly implemented.\r\n */\r\n if (++calls == 1)\r\n {\r\n srand((unsigned)(time(NULL) ^ ZCR_SEED2));\r\n }\r\n init_keys(passwd, pkeys, pcrc_32_tab);\r\n for (n = 0; n < RAND_HEAD_LEN-2; n++)\r\n {\r\n c = (rand() >> 7) & 0xff;\r\n header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);\r\n }\r\n /* Encrypt random header (last two bytes is high word of crc) */\r\n init_keys(passwd, pkeys, pcrc_32_tab);\r\n for (n = 0; n < RAND_HEAD_LEN-2; n++)\r\n {\r\n buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);\r\n }\r\n buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);\r\n buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);\r\n return n;\r\n}\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/defs.h",
"content": "#pragma once\r\n\r\nextern \"C\"\r\n{\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n#include <time.h>\r\n#include <errno.h>\r\n#include <fcntl.h>\r\n#include <sys/stat.h>\r\n\r\n#if (defined(_WIN32)) || (defined(_WIN64))\r\n# include <direct.h>\r\n# include <io.h>\r\n#else\r\n# include <unistd.h>\r\n# include <utime.h>\r\n#endif\r\n\r\n#include <zip.h>\r\n#include <unzip.h>\r\n#include <ioapi_mem.h>\r\n#define CASESENSITIVITY (0)\r\n#define WRITEBUFFERSIZE (8192)\r\n#define MAXFILENAME (256)\r\n\r\n#if (defined(_WIN32)) || (defined(_WIN64))\r\n#define USEWIN32IOAPI\r\n#include \"iowin32.h\"\r\n#endif\r\n}\r\n\r\n#if (defined(_WIN32)) || (defined(_WIN64))\r\n #include <filesystem>\r\n#endif\r\n\r\n#if (defined(_WIN32)) || (defined(_WIN64))\r\n #define EXCEPTION_CLASS std::exception\r\n#else\r\n #define EXCEPTION_CLASS std::runtime_error\r\n#endif\r\n\r\n\r\n#if (defined(_WIN64)) && (!defined(__APPLE__))\r\n#ifndef __USE_FILE_OFFSET64\r\n#define __USE_FILE_OFFSET64\r\n#endif\r\n#ifndef __USE_LARGEFILE64\r\n#define __USE_LARGEFILE64\r\n#endif\r\n#ifndef _LARGEFILE64_SOURCE\r\n#define _LARGEFILE64_SOURCE\r\n#endif\r\n#ifndef _FILE_OFFSET_BIT\r\n#define _FILE_OFFSET_BIT 64\r\n#endif\r\n#endif\r\n\r\n#if (defined(_WIN32)) || (defined(_WIN64))\r\n# define MKDIR(d) _mkdir(d)\r\n# define CHDIR(d) _chdir(d)\r\n#else\r\n# define MKDIR(d) mkdir(d, 0775)\r\n# define CHDIR(d) chdir(d)\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/ioapi.h",
"content": "/* ioapi.h -- IO base function header for compress/uncompress .zip\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications for Zip64 support\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _ZLIBIOAPI64_H\r\n#define _ZLIBIOAPI64_H\r\n\r\n#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))\r\n# ifndef __USE_FILE_OFFSET64\r\n# define __USE_FILE_OFFSET64\r\n# endif\r\n# ifndef __USE_LARGEFILE64\r\n# define __USE_LARGEFILE64\r\n# endif\r\n# ifndef _LARGEFILE64_SOURCE\r\n# define _LARGEFILE64_SOURCE\r\n# endif\r\n# ifndef _FILE_OFFSET_BIT\r\n# define _FILE_OFFSET_BIT 64\r\n# endif\r\n#endif\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include \"zlib.h\"\r\n\r\n#define USE_FILE32API\r\n\r\n#if defined(USE_FILE32API)\r\n# define fopen64 fopen\r\n# define ftello64 ftell\r\n# define fseeko64 fseek\r\n#else\r\n# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__)\r\n# define fopen64 fopen\r\n# define ftello64 ftello\r\n# define fseeko64 fseeko\r\n# endif\r\n# ifdef _MSC_VER\r\n# define fopen64 fopen\r\n# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))\r\n# define ftello64 _ftelli64\r\n# define fseeko64 _fseeki64\r\n# else /* old MSC */\r\n# define ftello64 ftell\r\n# define fseeko64 fseek\r\n# endif\r\n# endif\r\n#endif\r\n\r\n/* a type choosen by DEFINE */\r\n#ifdef HAVE_64BIT_INT_CUSTOM\r\ntypedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;\r\n#else\r\n# ifdef HAS_STDINT_H\r\n# include \"stdint.h\"\r\n typedef uint64_t ZPOS64_T;\r\n# else\r\n# if defined(_MSC_VER) || defined(__BORLANDC__)\r\n typedef unsigned __int64 ZPOS64_T;\r\n# else\r\n typedef unsigned long long int ZPOS64_T;\r\n# endif\r\n# endif\r\n#endif\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\n#define ZLIB_FILEFUNC_SEEK_CUR (1)\r\n#define ZLIB_FILEFUNC_SEEK_END (2)\r\n#define ZLIB_FILEFUNC_SEEK_SET (0)\r\n\r\n#define ZLIB_FILEFUNC_MODE_READ (1)\r\n#define ZLIB_FILEFUNC_MODE_WRITE (2)\r\n#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)\r\n#define ZLIB_FILEFUNC_MODE_EXISTING (4)\r\n#define ZLIB_FILEFUNC_MODE_CREATE (8)\r\n\r\n#ifndef ZCALLBACK\r\n# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \\\r\n defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)\r\n# define ZCALLBACK CALLBACK\r\n# else\r\n# define ZCALLBACK\r\n# endif\r\n#endif\r\n\r\ntypedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));\r\ntypedef voidpf (ZCALLBACK *opendisk_file_func) OF((voidpf opaque, voidpf stream, int number_disk, int mode));\r\ntypedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));\r\ntypedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));\r\ntypedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));\r\ntypedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));\r\n\r\ntypedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));\r\ntypedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));\r\n\r\n/* here is the \"old\" 32 bits structure structure */\r\ntypedef struct zlib_filefunc_def_s\r\n{\r\n open_file_func zopen_file;\r\n opendisk_file_func zopendisk_file;\r\n read_file_func zread_file;\r\n write_file_func zwrite_file;\r\n tell_file_func ztell_file;\r\n seek_file_func zseek_file;\r\n close_file_func zclose_file;\r\n testerror_file_func zerror_file;\r\n voidpf opaque;\r\n} zlib_filefunc_def;\r\n\r\ntypedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));\r\ntypedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));\r\ntypedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode));\r\ntypedef voidpf (ZCALLBACK *opendisk64_file_func)OF((voidpf opaque, voidpf stream, int number_disk, int mode));\r\n\r\ntypedef struct zlib_filefunc64_def_s\r\n{\r\n open64_file_func zopen64_file;\r\n opendisk64_file_func zopendisk64_file;\r\n read_file_func zread_file;\r\n write_file_func zwrite_file;\r\n tell64_file_func ztell64_file;\r\n seek64_file_func zseek64_file;\r\n close_file_func zclose_file;\r\n testerror_file_func zerror_file;\r\n voidpf opaque;\r\n} zlib_filefunc64_def;\r\n\r\nvoid fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));\r\nvoid fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));\r\n\r\n/* now internal definition, only for zip.c and unzip.h */\r\ntypedef struct zlib_filefunc64_32_def_s\r\n{\r\n zlib_filefunc64_def zfile_func64;\r\n open_file_func zopen32_file;\r\n opendisk_file_func zopendisk32_file;\r\n tell_file_func ztell32_file;\r\n seek_file_func zseek32_file;\r\n} zlib_filefunc64_32_def;\r\n\r\n#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))\r\n#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))\r\n/*#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))*/\r\n/*#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))*/\r\n#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))\r\n#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))\r\n\r\nvoidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));\r\nvoidpf call_zopendisk64 OF((const zlib_filefunc64_32_def* pfilefunc, voidpf filestream, int number_disk, int mode));\r\nlong call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));\r\nZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));\r\n\r\nvoid fill_zlib_filefunc64_32_def_from_filefunc32 OF((zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32));\r\n\r\n#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))\r\n#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode)))\r\n#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))\r\n#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/ioapi_buf.h",
"content": "/* ioapi_buf.h -- IO base function header for compress/uncompress .zip\r\n files using zlib + zip or unzip API\r\n\r\n This version of ioapi is designed to buffer IO.\r\n\r\n Copyright (C) 1998-2003 Gilles Vollant\r\n (C) 2012-2014 Nathan Moinvaziri\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _IOAPI_BUF_H\r\n#define _IOAPI_BUF_H\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n#include \"zlib.h\"\r\n#include \"ioapi.h\"\r\n\r\n#define IOBUF_BUFFERSIZE (64 * 1024)\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\nvoidpf ZCALLBACK fopen_buf_func OF((voidpf opaque,const char* filename,int mode));\r\nvoidpf ZCALLBACK fopen64_buf_func OF((voidpf opaque,const char* filename,int mode));\r\nvoidpf ZCALLBACK fopendisk_buf_func OF((voidpf opaque, voidpf stream_cd, int number_disk, int mode));\r\nvoidpf ZCALLBACK fopendisk64_buf_func OF((voidpf opaque, voidpf stream_cd, int number_disk, int mode));\r\nuLong ZCALLBACK fread_buf_func OF((voidpf opaque,voidpf stream,void* buf,uLong size));\r\nuLong ZCALLBACK fwrite_buf_func OF((voidpf opaque,voidpf stream,const void* buf,uLong size));\r\nlong ZCALLBACK ftell_buf_func OF((voidpf opaque,voidpf stream));\r\nZPOS64_T ZCALLBACK ftell64_buf_func OF((voidpf opaque, voidpf stream));\r\nlong ZCALLBACK fseek_buf_func OF((voidpf opaque,voidpf stream,uLong offset,int origin));\r\nlong ZCALLBACK fseek64_buf_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));\r\nint ZCALLBACK fclose_buf_func OF((voidpf opaque,voidpf stream));\r\nint ZCALLBACK ferror_buf_func OF((voidpf opaque,voidpf stream));\r\n\r\ntypedef struct ourbuffer_s {\r\n zlib_filefunc_def filefunc;\r\n zlib_filefunc64_def filefunc64;\r\n} ourbuffer_t;\r\n\r\nvoid fill_buffer_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def, ourbuffer_t *ourbuf));\r\nvoid fill_buffer_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def, ourbuffer_t *ourbuf));\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/ioapi_mem.h",
"content": "/* ioapi_mem.h -- IO base function header for compress/uncompress .zip\r\n files using zlib + zip or unzip API\r\n\r\n This version of ioapi is designed to access memory rather than files.\r\n We do use a region of memory to put data in to and take it out of. We do\r\n not have auto-extending buffers and do not inform anyone else that the\r\n data has been written. It is really intended for accessing a zip archive\r\n embedded in an application such that I can write an installer with no\r\n external files.\r\n\r\n Copyright (C) 1998-2003 Gilles Vollant\r\n (C) 2003 Justin Fletcher\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _IOAPI_MEM_H\r\n#define _IOAPI_MEM_H\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n#include \"zlib.h\"\r\n#include \"ioapi.h\"\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\nvoidpf ZCALLBACK fopen_mem_func OF((voidpf opaque,const char* filename,int mode));\r\nvoidpf ZCALLBACK fopendisk_mem_func OF((voidpf opaque, voidpf stream, int number_disk, int mode));\r\nuLong ZCALLBACK fread_mem_func OF((voidpf opaque,voidpf stream,void* buf,uLong size));\r\nuLong ZCALLBACK fwrite_mem_func OF((voidpf opaque,voidpf stream,const void* buf,uLong size));\r\nlong ZCALLBACK ftell_mem_func OF((voidpf opaque,voidpf stream));\r\nlong ZCALLBACK fseek_mem_func OF((voidpf opaque,voidpf stream,uLong offset,int origin));\r\nint ZCALLBACK fclose_mem_func OF((voidpf opaque,voidpf stream));\r\nint ZCALLBACK ferror_mem_func OF((voidpf opaque,voidpf stream));\r\n\r\ntypedef struct ourmemory_s {\r\n char *base; /* Base of the region of memory we're using */\r\n uLong size; /* Size of the region of memory we're using */\r\n uLong limit; /* Furthest we've written */\r\n uLong cur_offset; /* Current offset in the area */\r\n int grow; /* Growable memory buffer */\r\n} ourmemory_t;\r\n\r\nvoid fill_memory_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def, ourmemory_t *ourmem));\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/iowin32.h",
"content": "/* iowin32.h -- IO base function header for compress/uncompress .zip\r\n Version 1.1, February 14h, 2010\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications for Zip64 support\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _IOWIN32_H\r\n#define _IOWIN32_H\r\n\r\n#include <windows.h>\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\nvoid fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));\r\nvoid fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));\r\nvoid fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));\r\nvoid fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/include/tools.h",
"content": "#pragma once\r\n\r\n#include <string>\r\n#include <vector>\r\n#include <istream>\r\n\r\n\r\nnamespace zipper \r\n{\r\n void getFileCrc(std::istream& input_stream, std::vector<char>& buff, unsigned long& result_crc);\r\n bool isLargeFile(std::istream& input_stream);\r\n bool checkFileExists(const std::string& filename);\r\n bool makedir(const std::string& newdir);\r\n void removeFolder(const std::string& foldername);\r\n std::string parentDirectory(const std::string& filepath);\r\n std::string currentPath();\r\n bool isDirectory(const std::string& path);\r\n std::vector<std::string> filesFromDirectory(const std::string& path);\r\n std::string fileNameFromPath(const std::string& path);\r\n}\r\n"
},
{
"path": "libs/minizip/include/unzip.h",
"content": "/* unzip.h -- IO for uncompress .zip files using zlib\r\n Version 1.1, February 14h, 2010\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications of Unzip for Zip64\r\n Copyright (C) 2007-2008 Even Rouault\r\n Modifications for Zip64 support on both zip and unzip\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _UNZ_H\r\n#define _UNZ_H\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\n#ifndef _ZLIB_H\r\n#include \"zlib.h\"\r\n#endif\r\n\r\n#ifndef _ZLIBIOAPI_H\r\n#include \"ioapi.h\"\r\n#endif\r\n\r\n#ifdef HAVE_BZIP2\r\n#include \"bzlib.h\"\r\n#endif\r\n\r\n#define Z_BZIP2ED 12\r\n\r\n#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)\r\n/* like the STRICT of WIN32, we define a pointer that cannot be converted\r\n from (void*) without cast */\r\ntypedef struct TagunzFile__ { int unused; } unzFile__;\r\ntypedef unzFile__ *unzFile;\r\n#else\r\ntypedef voidp unzFile;\r\n#endif\r\n\r\n\r\n#define UNZ_OK (0)\r\n#define UNZ_END_OF_LIST_OF_FILE (-100)\r\n#define UNZ_ERRNO (Z_ERRNO)\r\n#define UNZ_EOF (0)\r\n#define UNZ_PARAMERROR (-102)\r\n#define UNZ_BADZIPFILE (-103)\r\n#define UNZ_INTERNALERROR (-104)\r\n#define UNZ_CRCERROR (-105)\r\n\r\n/* tm_unz contain date/time info */\r\ntypedef struct tm_unz_s\r\n{\r\n uInt tm_sec; /* seconds after the minute - [0,59] */\r\n uInt tm_min; /* minutes after the hour - [0,59] */\r\n uInt tm_hour; /* hours since midnight - [0,23] */\r\n uInt tm_mday; /* day of the month - [1,31] */\r\n uInt tm_mon; /* months since January - [0,11] */\r\n uInt tm_year; /* years - [1980..2044] */\r\n} tm_unz;\r\n\r\n/* unz_global_info structure contain global data about the ZIPfile\r\n These data comes from the end of central dir */\r\ntypedef struct unz_global_info64_s\r\n{\r\n ZPOS64_T number_entry; /* total number of entries in the central dir on this disk */\r\n uLong number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/\r\n uLong size_comment; /* size of the global comment of the zipfile */\r\n} unz_global_info64;\r\n\r\ntypedef struct unz_global_info_s\r\n{\r\n uLong number_entry; /* total number of entries in the central dir on this disk */\r\n uLong number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/\r\n uLong size_comment; /* size of the global comment of the zipfile */\r\n} unz_global_info;\r\n\r\n/* unz_file_info contain information about a file in the zipfile */\r\ntypedef struct unz_file_info64_s\r\n{\r\n uLong version; /* version made by 2 bytes */\r\n uLong version_needed; /* version needed to extract 2 bytes */\r\n uLong flag; /* general purpose bit flag 2 bytes */\r\n uLong compression_method; /* compression method 2 bytes */\r\n uLong dosDate; /* last mod file date in Dos fmt 4 bytes */\r\n uLong crc; /* crc-32 4 bytes */\r\n ZPOS64_T compressed_size; /* compressed size 8 bytes */\r\n ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */\r\n uLong size_filename; /* filename length 2 bytes */\r\n uLong size_file_extra; /* extra field length 2 bytes */\r\n uLong size_file_comment; /* file comment length 2 bytes */\r\n\r\n uLong disk_num_start; /* disk number start 2 bytes */\r\n uLong internal_fa; /* internal file attributes 2 bytes */\r\n uLong external_fa; /* external file attributes 4 bytes */\r\n\r\n tm_unz tmu_date;\r\n ZPOS64_T disk_offset;\r\n uLong size_file_extra_internal;\r\n} unz_file_info64;\r\n\r\ntypedef struct unz_file_info_s\r\n{\r\n uLong version; /* version made by 2 bytes */\r\n uLong version_needed; /* version needed to extract 2 bytes */\r\n uLong flag; /* general purpose bit flag 2 bytes */\r\n uLong compression_method; /* compression method 2 bytes */\r\n uLong dosDate; /* last mod file date in Dos fmt 4 bytes */\r\n uLong crc; /* crc-32 4 bytes */\r\n uLong compressed_size; /* compressed size 4 bytes */\r\n uLong uncompressed_size; /* uncompressed size 4 bytes */\r\n uLong size_filename; /* filename length 2 bytes */\r\n uLong size_file_extra; /* extra field length 2 bytes */\r\n uLong size_file_comment; /* file comment length 2 bytes */\r\n\r\n uLong disk_num_start; /* disk number start 2 bytes */\r\n uLong internal_fa; /* internal file attributes 2 bytes */\r\n uLong external_fa; /* external file attributes 4 bytes */\r\n\r\n tm_unz tmu_date;\r\n uLong disk_offset;\r\n} unz_file_info;\r\n\r\n/***************************************************************************/\r\n/* Opening and close a zip file */\r\n\r\nextern unzFile ZEXPORT unzOpen OF((const char *path));\r\nextern unzFile ZEXPORT unzOpen64 OF((const void *path));\r\n/* Open a Zip file.\r\n\r\n path should contain the full pathname (by example, on a Windows XP computer \r\n \"c:\\\\zlib\\\\zlib113.zip\" or on an Unix computer \"zlib/zlib113.zip\". \r\n return NULL if zipfile cannot be opened or doesn't exist\r\n return unzFile handle if no error\r\n\r\n NOTE: The \"64\" function take a const void* pointer, because the path is just the value passed to the\r\n open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path \r\n is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char* does not describe the reality */\r\n\r\nextern unzFile ZEXPORT unzOpen2 OF((const char *path, zlib_filefunc_def* pzlib_filefunc_def));\r\n/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */\r\nextern unzFile ZEXPORT unzOpen2_64 OF((const void *path, zlib_filefunc64_def* pzlib_filefunc_def));\r\n/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */\r\n\r\nextern int ZEXPORT unzClose OF((unzFile file));\r\n/* Close a ZipFile opened with unzipOpen. If there is files inside the .Zip opened with unzOpenCurrentFile,\r\n these files MUST be closed with unzipCloseCurrentFile before call unzipClose.\r\n\r\n return UNZ_OK if there is no error */\r\n\r\nextern int ZEXPORT unzGetGlobalInfo OF((unzFile file, unz_global_info *pglobal_info));\r\nextern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file, unz_global_info64 *pglobal_info));\r\n/* Write info about the ZipFile in the *pglobal_info structure.\r\n\r\n return UNZ_OK if no error */\r\n\r\nextern int ZEXPORT unzGetGlobalComment OF((unzFile file, char *comment, uLong comment_size));\r\n/* Get the global comment string of the ZipFile, in the comment buffer.\r\n\r\n uSizeBuf is the size of the szComment buffer.\r\n return the number of byte copied or an error code <0 */\r\n\r\n/***************************************************************************/\r\n/* Reading the content of the current zipfile, you can open it, read data from it, and close it\r\n (you can close it before reading all the file) */\r\n\r\nextern int ZEXPORT unzOpenCurrentFile OF((unzFile file));\r\n/* Open for reading data the current file in the zipfile.\r\n\r\n return UNZ_OK if no error */\r\n\r\nextern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, const char* password));\r\n/* Open for reading data the current file in the zipfile.\r\n password is a crypting password\r\n\r\n return UNZ_OK if no error */\r\n\r\nextern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, int* method, int* level, int raw));\r\n/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress)\r\n if raw==1 *method will receive method of compression, *level will receive level of compression\r\n\r\n NOTE: you can set level parameter as NULL (if you did not want known level,\r\n but you CANNOT set method parameter as NULL */\r\n\r\nextern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, int* method, int* level, int raw, const char* password));\r\n/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */\r\n\r\nextern int ZEXPORT unzReadCurrentFile OF((unzFile file, voidp buf, unsigned len));\r\n/* Read bytes from the current file (opened by unzOpenCurrentFile)\r\n buf contain buffer where data must be copied\r\n len the size of buf.\r\n\r\n return the number of byte copied if somes bytes are copied\r\n return 0 if the end of file was reached\r\n return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */\r\n\r\nextern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, unz_file_info *pfile_info, char *filename, \r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size));\r\nextern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size));\r\n/* Get Info about the current file\r\n\r\n pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file\r\n filename if != NULL, the file name string will be copied in filename \r\n filename_size is the size of the filename buffer\r\n extrafield if != NULL, the extra field information from the central header will be copied in to\r\n extrafield_size is the size of the extraField buffer \r\n comment if != NULL, the comment string of the file will be copied in to\r\n comment_size is the size of the comment buffer */\r\n\r\nextern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));\r\n\r\nextern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, voidp buf, unsigned len));\r\n/* Read extra field from the current file (opened by unzOpenCurrentFile)\r\n This is the local-header version of the extra field (sometimes, there is\r\n more info in the local-header version than in the central-header)\r\n\r\n if buf == NULL, it return the size of the local extra field\r\n if buf != NULL, len is the size of the buffer, the extra header is copied in buf.\r\n\r\n return number of bytes copied in buf, or (if <0) the error code */\r\n\r\nextern int ZEXPORT unzCloseCurrentFile OF((unzFile file));\r\n/* Close the file in zip opened with unzOpenCurrentFile\r\n\r\n return UNZ_CRCERROR if all the file was read but the CRC is not good */\r\n\r\n/***************************************************************************/\r\n/* Browse the directory of the zipfile */\r\n\r\ntypedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);\r\ntypedef int (*unzIteratorFunction)(unzFile file);\r\ntypedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size);\r\n\r\nextern int ZEXPORT unzGoToFirstFile OF((unzFile file));\r\n/* Set the current file of the zipfile to the first file.\r\n\r\n return UNZ_OK if no error */\r\n\r\nextern int ZEXPORT unzGoToFirstFile2 OF((unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size));\r\n/* Set the current file of the zipfile to the first file and retrieves the current info on success. \r\n Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo.\r\n\r\n return UNZ_OK if no error */\r\n\r\nextern int ZEXPORT unzGoToNextFile OF((unzFile file));\r\n/* Set the current file of the zipfile to the next file.\r\n\r\n return UNZ_OK if no error\r\n return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */\r\n\r\nextern int ZEXPORT unzGoToNextFile2 OF((unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size));\r\n/* Set the current file of the zipfile to the next file and retrieves the current \r\n info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo.\r\n\r\n return UNZ_OK if no error\r\n return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */\r\n\r\nextern int ZEXPORT unzLocateFile OF((unzFile file, const char *filename, unzFileNameComparer filename_compare_func));\r\n/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function.\r\n\r\n return UNZ_OK if the file is found (it becomes the current file)\r\n return UNZ_END_OF_LIST_OF_FILE if the file is not found */\r\n\r\n/***************************************************************************/\r\n/* Raw access to zip file */\r\n\r\ntypedef struct unz_file_pos_s\r\n{\r\n uLong pos_in_zip_directory; /* offset in zip file directory */\r\n uLong num_of_file; /* # of file */\r\n} unz_file_pos;\r\n\r\nextern int ZEXPORT unzGetFilePos OF((unzFile file, unz_file_pos* file_pos));\r\nextern int ZEXPORT unzGoToFilePos OF((unzFile file, unz_file_pos* file_pos));\r\n\r\ntypedef struct unz64_file_pos_s\r\n{\r\n ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */\r\n ZPOS64_T num_of_file; /* # of file */\r\n} unz64_file_pos;\r\n\r\nextern int ZEXPORT unzGetFilePos64 OF((unzFile file, unz64_file_pos* file_pos));\r\nextern int ZEXPORT unzGoToFilePos64 OF((unzFile file, const unz64_file_pos* file_pos));\r\n\r\nextern uLong ZEXPORT unzGetOffset OF((unzFile file));\r\nextern ZPOS64_T ZEXPORT unzGetOffset64 OF((unzFile file));\r\n/* Get the current file offset */\r\n\r\nextern int ZEXPORT unzSetOffset OF((unzFile file, uLong pos));\r\nextern int ZEXPORT unzSetOffset64 OF((unzFile file, ZPOS64_T pos));\r\n/* Set the current file offset */\r\n\r\nextern z_off_t ZEXPORT unztell OF((unzFile file));\r\nextern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));\r\n/* return current position in uncompressed data */\r\n\r\nextern int ZEXPORT unzeof OF((unzFile file));\r\n/* return 1 if the end of file was reached, 0 elsewhere */\r\n\r\n/***************************************************************************/\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif /* _UNZ_H */\r\n"
},
{
"path": "libs/minizip/include/unzipper.h",
"content": "#pragma once\r\n\r\n#include <vector>\r\n#include <istream>\r\n#include <ostream>\r\n#include <sstream>\r\n#include <string>\r\n#include <memory>\r\n#include <map>\r\n\r\nnamespace zipper {\r\n \r\n class ZipEntry;\r\n\r\n class Unzipper\r\n {\r\n public:\r\n Unzipper(std::istream& buffer);\r\n Unzipper(std::vector<unsigned char>& buffer);\r\n Unzipper(const std::string& zipname);\r\n Unzipper(const std::string& zipname, const std::string& password);\r\n\r\n ~Unzipper(void);\r\n\r\n std::vector<ZipEntry> entries();\r\n\r\n bool extract(const std::string& destination, const std::map<std::string, std::string>& alternativeNames);\r\n bool extract(const std::string& destination=std::string());\r\n bool extractEntry(const std::string& name, const std::string& destination = std::string());\r\n bool extractEntryToStream(const std::string& name, std::ostream& stream);\r\n bool extractEntryToMemory(const std::string& name, std::vector<unsigned char>& vec);\r\n\r\n void close();\r\n\r\n private:\r\n std::string m_password;\r\n std::string m_zipname;\r\n std::istream& m_ibuffer;\r\n std::vector<unsigned char>& m_vecbuffer;\r\n bool m_usingMemoryVector;\r\n bool m_usingStream;\r\n bool m_open;\r\n\r\n struct Impl;\r\n Impl* m_impl;\r\n };\r\n\r\n\r\n class ZipEntry\r\n {\r\n private:\r\n typedef struct\r\n {\r\n unsigned int tm_sec;\r\n unsigned int tm_min;\r\n unsigned int tm_hour;\r\n unsigned int tm_mday;\r\n unsigned int tm_mon;\r\n unsigned int tm_year;\r\n } tm_s;\r\n\r\n public:\r\n ZipEntry(const std::string& name, unsigned long long int compressed_size, unsigned long long int uncompressed_size,\r\n int year, int month, int day, int hour, int minute, int second, unsigned long dosdate)\r\n : name(name), compressedSize(compressed_size), uncompressedSize(uncompressed_size), dosdate(dosdate)\r\n {\r\n // timestamp YYYY-MM-DD HH:MM:SS\r\n std::stringstream str;\r\n str << year << \"-\" << month << \"-\" << day <<\r\n \" \" << hour << \":\" << minute << \":\" << second;\r\n timestamp = str.str();\r\n\r\n unixdate.tm_year = year;\r\n unixdate.tm_mon = month;\r\n unixdate.tm_mday = day;\r\n unixdate.tm_hour = hour;\r\n unixdate.tm_min = minute;\r\n unixdate.tm_sec = second;\r\n }\r\n\r\n bool valid() { return !name.empty(); }\r\n\r\n std::string name, timestamp;\r\n unsigned long long int compressedSize, uncompressedSize;\r\n unsigned long dosdate;\r\n tm_s unixdate;\r\n };\r\n}\r\n"
},
{
"path": "libs/minizip/include/zip.h",
"content": "/* zip.h -- IO on .zip files using zlib\r\n Version 1.1, February 14h, 2010\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications for Zip64 support\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#ifndef _ZIP_H\r\n#define _ZIP_H\r\n\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n\r\n#ifndef _ZLIB_H\r\n# include \"zlib.h\"\r\n#endif\r\n\r\n#ifndef _ZLIBIOAPI_H\r\n# include \"ioapi.h\"\r\n#endif\r\n\r\n#ifdef HAVE_BZIP2\r\n# include \"bzlib.h\"\r\n#endif\r\n\r\n#define Z_BZIP2ED 12\r\n\r\n#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)\r\n/* like the STRICT of WIN32, we define a pointer that cannot be converted\r\n from (void*) without cast */\r\ntypedef struct TagzipFile__ { int unused; } zipFile__;\r\ntypedef zipFile__ *zipFile;\r\n#else\r\ntypedef voidp zipFile;\r\n#endif\r\n\r\n#define ZIP_OK (0)\r\n#define ZIP_EOF (0)\r\n#define ZIP_ERRNO (Z_ERRNO)\r\n#define ZIP_PARAMERROR (-102)\r\n#define ZIP_BADZIPFILE (-103)\r\n#define ZIP_INTERNALERROR (-104)\r\n\r\n#ifndef DEF_MEM_LEVEL\r\n# if MAX_MEM_LEVEL >= 8\r\n# define DEF_MEM_LEVEL 8\r\n# else\r\n# define DEF_MEM_LEVEL MAX_MEM_LEVEL\r\n# endif\r\n#endif\r\n/* default memLevel */\r\n\r\n/* tm_zip contain date/time info */\r\ntypedef struct tm_zip_s\r\n{\r\n uInt tm_sec; /* seconds after the minute - [0,59] */\r\n uInt tm_min; /* minutes after the hour - [0,59] */\r\n uInt tm_hour; /* hours since midnight - [0,23] */\r\n uInt tm_mday; /* day of the month - [1,31] */\r\n uInt tm_mon; /* months since January - [0,11] */\r\n uInt tm_year; /* years - [1980..2044] */\r\n} tm_zip;\r\n\r\ntypedef struct\r\n{\r\n tm_zip tmz_date; /* date in understandable format */\r\n uLong dosDate; /* if dos_date == 0, tmu_date is used */\r\n uLong internal_fa; /* internal file attributes 2 bytes */\r\n uLong external_fa; /* external file attributes 4 bytes */\r\n} zip_fileinfo;\r\n\r\ntypedef const char* zipcharpc;\r\n\r\n#define APPEND_STATUS_CREATE (0)\r\n#define APPEND_STATUS_CREATEAFTER (1)\r\n#define APPEND_STATUS_ADDINZIP (2)\r\n\r\n/***************************************************************************/\r\n/* Writing a zip file */\r\n\r\nextern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));\r\nextern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));\r\n/* Create a zipfile.\r\n\r\n pathname should contain the full pathname (by example, on a Windows XP computer \r\n \"c:\\\\zlib\\\\zlib113.zip\" or on an Unix computer \"zlib/zlib113.zip\". \r\n\r\n return NULL if zipfile cannot be opened\r\n return zipFile handle if no error\r\n\r\n If the file pathname exist and append == APPEND_STATUS_CREATEAFTER, the zip\r\n will be created at the end of the file. (useful if the file contain a self extractor code)\r\n If the file pathname exist and append == APPEND_STATUS_ADDINZIP, we will add files in existing \r\n zip (be sure you don't add file that doesn't exist)\r\n\r\n NOTE: There is no delete function into a zipfile. If you want delete file into a zipfile, \r\n you must open a zipfile, and create another. Of course, you can use RAW reading and writing to copy\r\n the file you did not want delete. */\r\n\r\nextern zipFile ZEXPORT zipOpen2 OF((const char *pathname, int append, zipcharpc* globalcomment, \r\n zlib_filefunc_def* pzlib_filefunc_def));\r\n\r\nextern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname, int append, zipcharpc* globalcomment, \r\n zlib_filefunc64_def* pzlib_filefunc_def));\r\n\r\nextern zipFile ZEXPORT zipOpen3 OF((const char *pathname, int append, ZPOS64_T disk_size, \r\n zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc_def));\r\n/* Same as zipOpen2 but allows specification of spanned zip size */\r\n\r\nextern zipFile ZEXPORT zipOpen3_64 OF((const void *pathname, int append, ZPOS64_T disk_size, \r\n zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def));\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level));\r\n/* Open a file in the ZIP for writing.\r\n\r\n filename : the filename in zip (if NULL, '-' without quote will be used\r\n *zipfi contain supplemental information\r\n extrafield_local buffer to store the local header extra field data, can be NULL\r\n size_extrafield_local size of extrafield_local buffer\r\n extrafield_global buffer to store the global header extra field data, can be NULL\r\n size_extrafield_global size of extrafield_local buffer\r\n comment buffer for comment string\r\n method contain the compression method (0 for store, Z_DEFLATED for deflate)\r\n level contain the level of compression (can be Z_DEFAULT_COMPRESSION)\r\n zip64 is set to 1 if a zip64 extended information block should be added to the local file header.\r\n this MUST be '1' if the uncompressed size is >= 0xffffffff. */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int zip64));\r\n/* Same as zipOpenNewFileInZip with zip64 support */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw));\r\n/* Same as zipOpenNewFileInZip, except if raw=1, we write raw file */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int zip64));\r\n/* Same as zipOpenNewFileInZip3 with zip64 support */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, \r\n int strategy, const char* password, uLong crcForCrypting));\r\n/* Same as zipOpenNewFileInZip2, except\r\n windowBits, memLevel, strategy : see parameter strategy in deflateInit2\r\n password : crypting password (NULL for no crypting)\r\n crcForCrypting : crc of file to compress (needed for crypting) */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, \r\n int strategy, const char* password, uLong crcForCrypting, int zip64));\r\n/* Same as zipOpenNewFileInZip3 with zip64 support */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, \r\n int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase));\r\n/* Same as zipOpenNewFileInZip3 except versionMadeBy & flag fields */\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global, \r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel, \r\n int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase, int zip64));\r\n/* Same as zipOpenNewFileInZip4 with zip64 support */\r\n\r\nextern int ZEXPORT zipWriteInFileInZip OF((zipFile file, const void* buf, unsigned len));\r\n/* Write data in the zipfile */\r\n\r\nextern int ZEXPORT zipCloseFileInZip OF((zipFile file));\r\n/* Close the current file in the zipfile */\r\n\r\nextern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, uLong uncompressed_size, uLong crc32));\r\nextern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file, ZPOS64_T uncompressed_size, uLong crc32));\r\n/* Close the current file in the zipfile, for file opened with parameter raw=1 in zipOpenNewFileInZip2\r\n uncompressed_size and crc32 are value for the uncompressed size */\r\n\r\nextern int ZEXPORT zipClose OF((zipFile file, const char* global_comment));\r\n/* Close the zipfile */\r\n\r\n/***************************************************************************/\r\n\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n\r\n#endif /* _ZIP_H */\r\n"
},
{
"path": "libs/minizip/include/zipper.h",
"content": "#pragma once\r\n\r\n#include <iostream>\r\n#include <string>\r\n#include <sstream>\r\n#include <vector>\r\n#include <memory>\r\n\r\nnamespace zipper {\r\n\r\n\tclass Zipper\r\n\t{\r\n\tpublic:\r\n\t\t// Minizip options/params:\r\n\t\t// -o -a -0 -1 -9 -j\r\n\t\tenum zipFlags { Overwrite = 0x01, Append = 0x02, Store = 0x04, Faster = 0x08, Better = 0x10, NoPaths = 0x20 };\r\n\r\n\t\tZipper(std::iostream& buffer);\r\n\t\tZipper(std::vector<unsigned char>& buffer);\r\n\t\tZipper(const std::string& zipname);\r\n\t\tZipper(const std::string& zipname, const std::string& password);\r\n\r\n\t\t~Zipper(void);\r\n\r\n\t\tbool add(std::istream& source, const std::string& nameInZip = std::string(), zipFlags flags = Better);\r\n\t\tbool add(const std::string& fileOrFolderPath, zipFlags flags = Better);\r\n\t\t\r\n\t\tvoid open();\r\n\t\tvoid close();\r\n\r\n\tprivate:\r\n\t\tstd::string m_password;\r\n\t\tstd::string m_zipname;\r\n\t\tstd::iostream& m_obuffer;\r\n\t\tstd::vector<unsigned char>& m_vecbuffer;\r\n\t\tbool m_usingMemoryVector;\r\n\t\tbool m_usingStream;\r\n\t\tbool m_open;\r\n\r\n\t\tstruct Impl;\r\n\t\tImpl* m_impl;\r\n\t};\r\n}\r\n"
},
{
"path": "libs/minizip/source/CDirEntry.cpp",
"content": "// Copyright (C) 2010 - 2014 by Pedro Mendes, Virginia Tech Intellectual\r\n// Properties, Inc., University of Heidelberg, and The University\r\n// of Manchester.\r\n// All rights reserved.\r\n\r\n// Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual\r\n// Properties, Inc., EML Research, gGmbH, University of Heidelberg,\r\n// and The University of Manchester.\r\n// All rights reserved.\r\n\r\n// Copyright (C) 2005 - 2007 by Pedro Mendes, Virginia Tech Intellectual\r\n// Properties, Inc. and EML Research, gGmbH.\r\n// All rights reserved.\r\n\r\n#include <algorithm>\r\n#include <sys/types.h>\r\n#include <sys/stat.h>\r\n\r\n#ifdef WIN32\r\n# include <io.h>\r\n# include <direct.h>\r\ntypedef struct _stat STAT;\r\n# define stat _stat\r\n# define S_IFREG _S_IFREG\r\n# define S_IFDIR _S_IFDIR\r\n# define access _access\r\n# define mkdir _mkdir\r\n# define rmdir _rmdir\r\n#else\r\ntypedef struct stat STAT;\r\n# include <dirent.h>\r\n# include <unistd.h>\r\n#endif // WIN32\r\n\r\n#include \"CDirEntry.h\"\r\n\r\n#include <stdlib.h>\r\n\r\n#include <fstream>\r\n\r\nusing namespace zipper;\r\n\r\n#ifdef WIN32\r\nconst std::string CDirEntry::Separator = \"\\\\\";\r\n#else\r\nconst std::string CDirEntry::Separator = \"/\";\r\n#endif\r\n\r\nbool CDirEntry::isFile(const std::string & path)\r\n{\r\n STAT st;\r\n\r\n if (stat(path.c_str(), & st) == -1) return false;\r\n\r\n#ifdef WIN32\r\n return ((st.st_mode & S_IFREG) == S_IFREG);\r\n#else\r\n return S_ISREG(st.st_mode);\r\n#endif\r\n}\r\n\r\nbool CDirEntry::isDir(const std::string & path)\r\n{\r\n STAT st;\r\n\r\n if (stat(path.c_str(), & st) == -1) return false;\r\n\r\n#ifdef WIN32\r\n return ((st.st_mode & S_IFDIR) == S_IFDIR);\r\n#else\r\n return S_ISDIR(st.st_mode);\r\n#endif\r\n}\r\n\r\nbool CDirEntry::exist(const std::string & path)\r\n{\r\n STAT st;\r\n\r\n if (stat(path.c_str(), & st) == -1) return false;\r\n\r\n#ifdef WIN32\r\n return ((st.st_mode & S_IFREG) == S_IFREG ||\r\n (st.st_mode & S_IFDIR) == S_IFDIR);\r\n#else\r\n return (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode));\r\n#endif\r\n}\r\n\r\nbool CDirEntry::isReadable(const std::string & path)\r\n{return (access(path.c_str(), 0x4) == 0);}\r\n\r\nbool CDirEntry::isWritable(const std::string & path)\r\n{return (access(path.c_str(), 0x2) == 0);}\r\n\r\nstd::string CDirEntry::baseName(const std::string & path)\r\n{\r\n std::string::size_type start = path.find_last_of(Separator);\r\n#ifdef WIN32 // WIN32 also understands '/' as the separator.\r\n\r\n if (start == std::string::npos)\r\n start = path.find_last_of(\"/\");\r\n\r\n#endif\r\n\r\n if (start == std::string::npos) start = 0;\r\n else start++; // We do not want the separator.\r\n\r\n std::string::size_type end = path.find_last_of(\".\");\r\n\r\n if (end == std::string::npos || end < start)\r\n end = path.length();\r\n\r\n return path.substr(start, end - start);\r\n}\r\n\r\nstd::string CDirEntry::fileName(const std::string & path)\r\n{\r\n std::string::size_type start = path.find_last_of(Separator);\r\n#ifdef WIN32 // WIN32 also understands '/' as the separator.\r\n\r\n if (start == std::string::npos)\r\n start = path.find_last_of(\"/\");\r\n\r\n#endif\r\n\r\n if (start == std::string::npos) start = 0;\r\n else start++; // We do not want the separator.\r\n\r\n return path.substr(start);\r\n}\r\n\r\nstd::string CDirEntry::dirName(const std::string & path)\r\n{\r\n if (path == \"\") return path;\r\n\r\n#ifdef WIN32 // WIN32 also understands '/' as the separator.\r\n std::string::size_type end = path.find_last_of(Separator + \"/\");\r\n#else\r\n std::string::size_type end = path.find_last_of(Separator);\r\n#endif\r\n\r\n if (end == path.length() - 1)\r\n {\r\n#ifdef WIN32 // WIN32 also understands '/' as the separator.\r\n end = path.find_last_of(Separator + \"/\", end);\r\n#else\r\n end = path.find_last_of(Separator, end);\r\n#endif\r\n }\r\n\r\n if (end == std::string::npos) return \"\";\r\n\r\n return path.substr(0, end);\r\n}\r\n\r\nstd::string CDirEntry::suffix(const std::string & path)\r\n{\r\n std::string::size_type start = path.find_last_of(Separator);\r\n#ifdef WIN32 // WIN32 also understands '/' as the separator.\r\n\r\n if (start == std::string::npos)\r\n start = path.find_last_of(\"/\");\r\n\r\n#endif\r\n\r\n if (start == std::string::npos) start = 0;\r\n else start++; // We do not want the separator.\r\n\r\n std::string::size_type end = path.find_last_of(\".\");\r\n\r\n if (end == std::string::npos || end < start)\r\n return \"\";\r\n else\r\n return path.substr(end);\r\n}\r\n\r\nbool CDirEntry::createDir(const std::string & dir,\r\n const std::string & parent)\r\n{\r\n std::string Dir;\r\n\r\n if (parent != \"\") Dir = parent + Separator;\r\n\r\n Dir += dir;\r\n\r\n // Check whether the directory already exists and is writable.\r\n if (isDir(Dir) && isWritable(Dir)) return true;\r\n\r\n // Check whether the parent directory exists and is writable.\r\n if (!parent.empty() && (!isDir(parent) || !isWritable(parent))) return false;\r\n\r\n Dir = normalize(Dir);\r\n\r\n // ensure we have parent\r\n std::string actualParent = dirName(Dir);\r\n\r\n if (!actualParent.empty() && (!exist(actualParent)))\r\n createDir(actualParent);\r\n\r\n#ifdef WIN32\r\n return (mkdir(Dir.c_str()) == 0);\r\n#else\r\n return (mkdir(Dir.c_str(), S_IRWXU | S_IRWXG | S_IRWXO) == 0);\r\n#endif\r\n}\r\n\r\nstd::string CDirEntry::createTmpName(const std::string & dir,\r\n const std::string & suffix)\r\n{\r\n std::string RandomName;\r\n\r\n do\r\n {\r\n RandomName = dir + Separator;\r\n unsigned int Char;\r\n\r\n for (size_t i = 0; i < 8; i++)\r\n {\r\n Char = int((rand()/double(RAND_MAX))*35.0);\r\n\r\n if (Char < 10)\r\n RandomName += '0' + Char;\r\n else\r\n RandomName += 'a' - 10 + Char;\r\n }\r\n\r\n RandomName += suffix;\r\n }\r\n while (exist(RandomName));\r\n\r\n return RandomName;\r\n}\r\n\r\nbool CDirEntry::move(const std::string & from,\r\n const std::string & to)\r\n{\r\n if (!isFile(from)) return false;\r\n\r\n std::string To = to;\r\n\r\n // Check whether To is a directory and append the\r\n // filename of from\r\n if (isDir(To))\r\n To += Separator + fileName(from);\r\n\r\n if (isDir(To)) return false;\r\n\r\n#ifdef WIN32\r\n\r\n // The target must not exist under WIN32 for rename to succeed.\r\n if (exist(To) && !remove(To))\r\n return false;\r\n\r\n#endif // WIN32\r\n\r\n bool success =\r\n (::rename(from.c_str(), To.c_str()) == 0);\r\n\r\n if (!success)\r\n {\r\n {\r\n std::ifstream in(from.c_str());\r\n std::ofstream out(To.c_str());\r\n\r\n out << in.rdbuf();\r\n\r\n success = out.good();\r\n }\r\n\r\n remove(from);\r\n }\r\n\r\n return success;\r\n}\r\n\r\nbool CDirEntry::remove(const std::string & path)\r\n{\r\n if (isDir(path))\r\n return (rmdir(path.c_str()) == 0);\r\n else if (isFile(path))\r\n#ifdef WIN32\r\n return (::remove(path.c_str()) == 0);\r\n\r\n#else\r\n return (::remove(path.c_str()) == 0);\r\n#endif\r\n\r\n return false;\r\n}\r\n\r\nbool CDirEntry::removeFiles(const std::string & pattern,\r\n const std::string & path)\r\n{\r\n bool success = true;\r\n std::vector< std::string > PatternList;\r\n\r\n PatternList = compilePattern(pattern);\r\n\r\n#ifdef WIN32\r\n\r\n // We want the same pattern matching behaviour for all platforms.\r\n // Therefore, we do not use the MS provided one and list all files instead.\r\n std::string FilePattern = path + \"\\\\*\";\r\n\r\n // Open directory stream and try read info about first entry\r\n struct _finddata_t Entry;\r\n intptr_t hList = _findfirst(FilePattern.c_str(), &Entry);\r\n\r\n if (hList == -1) return success;\r\n\r\n do\r\n {\r\n std::string Utf8 = Entry.name;\r\n\r\n if (match(Utf8, PatternList))\r\n {\r\n if (Entry.attrib | _A_NORMAL)\r\n {\r\n#ifdef WIN32\r\n\r\n if (::remove((path + Separator + Utf8).c_str()) != 0) success = false;\r\n\r\n#else\r\n\r\n if (::remove((path + Separator + Utf8).c_str()) != 0) success = false;\r\n\r\n#endif\r\n }\r\n else\r\n {\r\n if (rmdir((path + Separator + Utf8).c_str()) != 0) success = false;\r\n }\r\n }\r\n }\r\n while (_findnext(hList, &Entry) == 0);\r\n\r\n _findclose(hList);\r\n\r\n#else\r\n\r\n DIR * pDir = opendir(path.c_str());\r\n\r\n if (!pDir) return false;\r\n\r\n struct dirent * pEntry;\r\n\r\n while ((pEntry = readdir(pDir)) != NULL)\r\n {\r\n std::string Utf8 = pEntry->d_name;\r\n\r\n if (match(Utf8, PatternList))\r\n {\r\n if (isDir(Utf8))\r\n {\r\n if (::rmdir((path + Separator + Utf8).c_str()) != 0)\r\n success = false;\r\n }\r\n else\r\n {\r\n if (::remove((path + Separator + Utf8).c_str()) != 0)\r\n success = false;\r\n }\r\n }\r\n }\r\n\r\n closedir(pDir);\r\n\r\n#endif // WIN32\r\n\r\n return success;\r\n}\r\n\r\nstd::vector< std::string > CDirEntry::compilePattern(const std::string & pattern)\r\n{\r\n std::string::size_type pos = 0;\r\n std::string::size_type start = 0;\r\n std::string::size_type end = 0;\r\n std::vector< std::string > PatternList;\r\n\r\n while (pos != std::string::npos)\r\n {\r\n start = pos;\r\n pos = pattern.find_first_of(\"*?\", pos);\r\n\r\n end = std::min(pos, pattern.length());\r\n\r\n if (start != end)\r\n PatternList.push_back(pattern.substr(start, end - start));\r\n else\r\n {\r\n PatternList.push_back(pattern.substr(start, 1));\r\n pos++;\r\n }\r\n };\r\n\r\n return PatternList;\r\n}\r\n\r\nbool CDirEntry::match(const std::string & name,\r\n const std::vector< std::string > & patternList)\r\n{\r\n std::vector< std::string >::const_iterator it = patternList.begin();\r\n std::vector< std::string >::const_iterator end = patternList.end();\r\n std::string::size_type at = 0;\r\n std::string::size_type after = 0;\r\n\r\n bool Match = true;\r\n\r\n while (it != end && Match)\r\n Match = matchInternal(name, *it++, at, after);\r\n\r\n return Match;\r\n}\r\n\r\nbool CDirEntry::isRelativePath(const std::string & path)\r\n{\r\n#ifdef WIN32\r\n std::string Path = normalize(path);\r\n\r\n if (Path.length() < 2)\r\n return true;\r\n\r\n if (Path[1] == ':')\r\n return false;\r\n\r\n if (Path[0] == '/' && Path[1] == '/')\r\n return false;\r\n\r\n return true;\r\n#else\r\n return (path.length() < 1 || path[0] != '/');\r\n#endif\r\n}\r\n\r\nbool CDirEntry::makePathRelative(std::string & absolutePath,\r\n const std::string & relativeTo)\r\n{\r\n if (isRelativePath(absolutePath) ||\r\n isRelativePath(relativeTo)) return false; // Nothing can be done.\r\n\r\n std:: string RelativeTo = normalize(relativeTo);\r\n\r\n if (isFile(RelativeTo)) RelativeTo = dirName(RelativeTo);\r\n\r\n if (!isDir(RelativeTo)) return false;\r\n\r\n absolutePath = normalize(absolutePath);\r\n\r\n size_t i, imax = std::min(absolutePath.length(), RelativeTo.length());\r\n\r\n for (i = 0; i < imax; i++)\r\n if (absolutePath[i] != RelativeTo[i]) break;\r\n\r\n // We need to retract to the beginning of the current directory.\r\n if (i != imax)\r\n i = absolutePath.find_last_of('/', i) + 1;\r\n\r\n#ifdef WIN32\r\n\r\n if (i == 0) return false; // A different drive letter we cannot do anything\r\n\r\n#endif\r\n\r\n RelativeTo = RelativeTo.substr(i);\r\n\r\n std::string relativePath;\r\n\r\n while (RelativeTo != \"\")\r\n {\r\n relativePath += \"../\";\r\n RelativeTo = dirName(RelativeTo);\r\n }\r\n\r\n if (relativePath != \"\")\r\n absolutePath = relativePath + absolutePath.substr(i);\r\n else\r\n absolutePath = absolutePath.substr(i + 1);\r\n\r\n return true;\r\n}\r\n\r\nbool CDirEntry::makePathAbsolute(std::string & relativePath,\r\n const std::string & absoluteTo)\r\n{\r\n if (!isRelativePath(relativePath) ||\r\n isRelativePath(absoluteTo)) return false; // Nothing can be done.\r\n\r\n std:: string AbsoluteTo = normalize(absoluteTo);\r\n\r\n if (isFile(AbsoluteTo)) AbsoluteTo = dirName(AbsoluteTo);\r\n\r\n if (!isDir(AbsoluteTo)) return false;\r\n\r\n relativePath = normalize(relativePath);\r\n\r\n while (!relativePath.compare(0, 3, \"../\"))\r\n {\r\n AbsoluteTo = dirName(AbsoluteTo);\r\n relativePath = relativePath.substr(3);\r\n }\r\n\r\n relativePath = AbsoluteTo + \"/\" + relativePath;\r\n\r\n return true;\r\n}\r\n\r\nbool CDirEntry::matchInternal(const std::string & name,\r\n const std::string pattern,\r\n std::string::size_type & at,\r\n std::string::size_type & after)\r\n{\r\n bool Match = true;\r\n\r\n switch (pattern[0])\r\n {\r\n case '*':\r\n\r\n if (at != std::string::npos)\r\n {\r\n after = at;\r\n at = std::string::npos;\r\n }\r\n\r\n break;\r\n\r\n case '?':\r\n\r\n if (at != std::string::npos)\r\n {\r\n ++at;\r\n Match = (name.length() >= at);\r\n }\r\n else\r\n {\r\n ++after;\r\n Match = (name.length() >= after);\r\n }\r\n\r\n break;\r\n\r\n default:\r\n\r\n if (at != std::string::npos)\r\n {\r\n Match = (name.compare(at, pattern.length(), pattern) == 0);\r\n at += pattern.length();\r\n }\r\n else\r\n {\r\n at = name.find(pattern, after);\r\n Match = (at != std::string::npos);\r\n at += pattern.length();\r\n }\r\n\r\n break;\r\n }\r\n\r\n return Match;\r\n}\r\n\r\nstd::string CDirEntry::normalize(const std::string & path)\r\n{\r\n std::string Normalized = path;\r\n\r\n#ifdef WIN32\r\n // converts all '\\' to '/' (only on WIN32)\r\n size_t i, imax;\r\n\r\n for (i = 0, imax = Normalized.length(); i < imax; i++)\r\n if (Normalized[i] == '\\\\') Normalized[i] = '/';\r\n\r\n#endif\r\n\r\n // Remove leading './'\r\n while (!Normalized.compare(0, 2, \"./\"))\r\n Normalized = Normalized.substr(2);\r\n\r\n // Collapse '//' to '/'\r\n std::string::size_type pos = 1;\r\n\r\n while (true)\r\n {\r\n pos = Normalized.find(\"//\", pos);\r\n\r\n if (pos == std::string::npos) break;\r\n\r\n Normalized.erase(pos, 1);\r\n }\r\n\r\n // Collapse '/./' to '/'\r\n pos = 0;\r\n\r\n while (true)\r\n {\r\n pos = Normalized.find(\"/./\", pos);\r\n\r\n if (pos == std::string::npos) break;\r\n\r\n Normalized.erase(pos, 2);\r\n }\r\n\r\n // Collapse '[^/]+/../' to '/'\r\n std::string::size_type start = Normalized.length();\r\n\r\n while (true)\r\n {\r\n pos = Normalized.rfind(\"/../\", start);\r\n\r\n if (pos == std::string::npos) break;\r\n\r\n start = Normalized.rfind('/', pos - 1);\r\n\r\n if (start == std::string::npos) break;\r\n\r\n if (!Normalized.compare(start, 4, \"/../\")) continue;\r\n\r\n Normalized.erase(start, pos - start + 3);\r\n start = Normalized.length();\r\n }\r\n\r\n return Normalized;\r\n}\r\n"
},
{
"path": "libs/minizip/source/aes/Makefile",
"content": "CC=cc\r\nCFLAGS=-O -DHAVE_AES\r\nOBJS=aescrypt.o aeskey.o aestab.o entropy.o fileenc.o hmac.o prng.o pwd2key.o sha1.o\r\nARFLAGS=rv\r\n\r\n.c.o:\r\n\t$(CC) -c $(CFLAGS) $*.c\r\n\r\nlibaes.a: $(OBJS)\r\n\t$(ECHO) $(AR) $(ARFLAGS) ../libaes.a $?\r\n\t$(AR) $(ARFLAGS) ../libaes.a $?\r\n\t$(RANLIB) ../libaes.a\r\n\r\nall: libaes.a\r\n\r\n.PHONY: clean\r\n\r\nclean:\r\n\trm *.o *.a"
},
{
"path": "libs/minizip/source/aes/aes.h",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n\r\n This file contains the definitions required to use AES in C. See aesopt.h\r\n for optimisation details.\r\n*/\r\n\r\n#ifndef _AES_H\r\n#define _AES_H\r\n\r\n#include <stdlib.h>\r\n\r\n/* This include is used to find 8 & 32 bit unsigned integer types */\r\n#include \"brg_types.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#define AES_128 /* if a fast 128 bit key scheduler is needed */\r\n#define AES_192 /* if a fast 192 bit key scheduler is needed */\r\n#define AES_256 /* if a fast 256 bit key scheduler is needed */\r\n#define AES_VAR /* if variable key size scheduler is needed */\r\n#define AES_MODES /* if support is needed for modes */\r\n\r\n/* The following must also be set in assembler files if being used */\r\n\r\n#define AES_ENCRYPT /* if support for encryption is needed */\r\n#define AES_DECRYPT /* if support for decryption is needed */\r\n#define AES_REV_DKS /* define to reverse decryption key schedule */\r\n\r\n#define AES_BLOCK_SIZE 16 /* the AES block size in bytes */\r\n#define N_COLS 4 /* the number of columns in the state */\r\n\r\n/* The key schedule length is 11, 13 or 15 16-byte blocks for 128, */\r\n/* 192 or 256-bit keys respectively. That is 176, 208 or 240 bytes */\r\n/* or 44, 52 or 60 32-bit words. */\r\n\r\n#if defined( AES_VAR ) || defined( AES_256 )\r\n#define KS_LENGTH 60\r\n#elif defined( AES_192 )\r\n#define KS_LENGTH 52\r\n#else\r\n#define KS_LENGTH 44\r\n#endif\r\n\r\n#define AES_RETURN INT_RETURN\r\n\r\n/* the character array 'inf' in the following structures is used */\r\n/* to hold AES context information. This AES code uses cx->inf.b[0] */\r\n/* to hold the number of rounds multiplied by 16. The other three */\r\n/* elements can be used by code that implements additional modes */\r\n\r\ntypedef union\r\n{ uint_32t l;\r\n uint_8t b[4];\r\n} aes_inf;\r\n\r\ntypedef struct\r\n{ uint_32t ks[KS_LENGTH];\r\n aes_inf inf;\r\n} aes_encrypt_ctx;\r\n\r\ntypedef struct\r\n{ uint_32t ks[KS_LENGTH];\r\n aes_inf inf;\r\n} aes_decrypt_ctx;\r\n\r\n/* This routine must be called before first use if non-static */\r\n/* tables are being used */\r\n\r\nAES_RETURN aes_init(void);\r\n\r\n/* Key lengths in the range 16 <= key_len <= 32 are given in bytes, */\r\n/* those in the range 128 <= key_len <= 256 are given in bits */\r\n\r\n#if defined( AES_ENCRYPT )\r\n\r\n#if defined( AES_128 ) || defined( AES_VAR)\r\nAES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_192 ) || defined( AES_VAR)\r\nAES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_256 ) || defined( AES_VAR)\r\nAES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_VAR )\r\nAES_RETURN aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1]);\r\n#endif\r\n\r\nAES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1]);\r\n\r\n#endif\r\n\r\n#if defined( AES_DECRYPT )\r\n\r\n#if defined( AES_128 ) || defined( AES_VAR)\r\nAES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_192 ) || defined( AES_VAR)\r\nAES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_256 ) || defined( AES_VAR)\r\nAES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n#endif\r\n\r\n#if defined( AES_VAR )\r\nAES_RETURN aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1]);\r\n#endif\r\n\r\nAES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1]);\r\n\r\n#endif\r\n\r\n#if defined( AES_MODES )\r\n\r\n/* Multiple calls to the following subroutines for multiple block */\r\n/* ECB, CBC, CFB, OFB and CTR mode encryption can be used to handle */\r\n/* long messages incremantally provided that the context AND the iv */\r\n/* are preserved between all such calls. For the ECB and CBC modes */\r\n/* each individual call within a series of incremental calls must */\r\n/* process only full blocks (i.e. len must be a multiple of 16) but */\r\n/* the CFB, OFB and CTR mode calls can handle multiple incremental */\r\n/* calls of any length. Each mode is reset when a new AES key is */\r\n/* set but ECB and CBC operations can be reset without setting a */\r\n/* new key by setting a new IV value. To reset CFB, OFB and CTR */\r\n/* without setting the key, aes_mode_reset() must be called and the */\r\n/* IV must be set. NOTE: All these calls update the IV on exit so */\r\n/* this has to be reset if a new operation with the same IV as the */\r\n/* previous one is required (or decryption follows encryption with */\r\n/* the same IV array). */\r\n\r\nAES_RETURN aes_test_alignment_detection(unsigned int n);\r\n\r\nAES_RETURN aes_ecb_encrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, const aes_encrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_ecb_decrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, const aes_decrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_cbc_encrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *iv, const aes_encrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_cbc_decrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *iv, const aes_decrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_mode_reset(aes_encrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_cfb_encrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *iv, aes_encrypt_ctx cx[1]);\r\n\r\nAES_RETURN aes_cfb_decrypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *iv, aes_encrypt_ctx cx[1]);\r\n\r\n#define aes_ofb_encrypt aes_ofb_crypt\r\n#define aes_ofb_decrypt aes_ofb_crypt\r\n\r\nAES_RETURN aes_ofb_crypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *iv, aes_encrypt_ctx cx[1]);\r\n\r\ntypedef void cbuf_inc(unsigned char *cbuf);\r\n\r\n#define aes_ctr_encrypt aes_ctr_crypt\r\n#define aes_ctr_decrypt aes_ctr_crypt\r\n\r\nAES_RETURN aes_ctr_crypt(const unsigned char *ibuf, unsigned char *obuf,\r\n int len, unsigned char *cbuf, cbuf_inc ctr_inc, aes_encrypt_ctx cx[1]);\r\n\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/aes_via_ace.h",
"content": "/*\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n*/\r\n\r\n#ifndef AES_VIA_ACE_H\r\n#define AES_VIA_ACE_H\r\n\r\n#if defined( _MSC_VER )\r\n# define INLINE __inline\r\n#elif defined( __GNUC__ )\r\n# define INLINE static inline\r\n#else\r\n# error VIA ACE requires Microsoft or GNU C\r\n#endif\r\n\r\n#define NEH_GENERATE 1\r\n#define NEH_LOAD 2\r\n#define NEH_HYBRID 3\r\n\r\n#define MAX_READ_ATTEMPTS 1000\r\n\r\n/* VIA Nehemiah RNG and ACE Feature Mask Values */\r\n\r\n#define NEH_CPU_IS_VIA 0x00000001\r\n#define NEH_CPU_READ 0x00000010\r\n#define NEH_CPU_MASK 0x00000011\r\n\r\n#define NEH_RNG_PRESENT 0x00000004\r\n#define NEH_RNG_ENABLED 0x00000008\r\n#define NEH_ACE_PRESENT 0x00000040\r\n#define NEH_ACE_ENABLED 0x00000080\r\n#define NEH_RNG_FLAGS (NEH_RNG_PRESENT | NEH_RNG_ENABLED)\r\n#define NEH_ACE_FLAGS (NEH_ACE_PRESENT | NEH_ACE_ENABLED)\r\n#define NEH_FLAGS_MASK (NEH_RNG_FLAGS | NEH_ACE_FLAGS)\r\n\r\n/* VIA Nehemiah Advanced Cryptography Engine (ACE) Control Word Values */\r\n\r\n#define NEH_GEN_KEY 0x00000000 /* generate key schedule */\r\n#define NEH_LOAD_KEY 0x00000080 /* load schedule from memory */\r\n#define NEH_ENCRYPT 0x00000000 /* encryption */\r\n#define NEH_DECRYPT 0x00000200 /* decryption */\r\n#define NEH_KEY128 0x00000000+0x0a /* 128 bit key */\r\n#define NEH_KEY192 0x00000400+0x0c /* 192 bit key */\r\n#define NEH_KEY256 0x00000800+0x0e /* 256 bit key */\r\n\r\n#define NEH_ENC_GEN (NEH_ENCRYPT | NEH_GEN_KEY)\r\n#define NEH_DEC_GEN (NEH_DECRYPT | NEH_GEN_KEY)\r\n#define NEH_ENC_LOAD (NEH_ENCRYPT | NEH_LOAD_KEY)\r\n#define NEH_DEC_LOAD (NEH_DECRYPT | NEH_LOAD_KEY)\r\n\r\n#define NEH_ENC_GEN_DATA {\\\r\n NEH_ENC_GEN | NEH_KEY128, 0, 0, 0,\\\r\n NEH_ENC_GEN | NEH_KEY192, 0, 0, 0,\\\r\n NEH_ENC_GEN | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define NEH_ENC_LOAD_DATA {\\\r\n NEH_ENC_LOAD | NEH_KEY128, 0, 0, 0,\\\r\n NEH_ENC_LOAD | NEH_KEY192, 0, 0, 0,\\\r\n NEH_ENC_LOAD | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define NEH_ENC_HYBRID_DATA {\\\r\n NEH_ENC_GEN | NEH_KEY128, 0, 0, 0,\\\r\n NEH_ENC_LOAD | NEH_KEY192, 0, 0, 0,\\\r\n NEH_ENC_LOAD | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define NEH_DEC_GEN_DATA {\\\r\n NEH_DEC_GEN | NEH_KEY128, 0, 0, 0,\\\r\n NEH_DEC_GEN | NEH_KEY192, 0, 0, 0,\\\r\n NEH_DEC_GEN | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define NEH_DEC_LOAD_DATA {\\\r\n NEH_DEC_LOAD | NEH_KEY128, 0, 0, 0,\\\r\n NEH_DEC_LOAD | NEH_KEY192, 0, 0, 0,\\\r\n NEH_DEC_LOAD | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define NEH_DEC_HYBRID_DATA {\\\r\n NEH_DEC_GEN | NEH_KEY128, 0, 0, 0,\\\r\n NEH_DEC_LOAD | NEH_KEY192, 0, 0, 0,\\\r\n NEH_DEC_LOAD | NEH_KEY256, 0, 0, 0 }\r\n\r\n#define neh_enc_gen_key(x) ((x) == 128 ? (NEH_ENC_GEN | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_ENC_GEN | NEH_KEY192) : (NEH_ENC_GEN | NEH_KEY256))\r\n\r\n#define neh_enc_load_key(x) ((x) == 128 ? (NEH_ENC_LOAD | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_ENC_LOAD | NEH_KEY192) : (NEH_ENC_LOAD | NEH_KEY256))\r\n\r\n#define neh_enc_hybrid_key(x) ((x) == 128 ? (NEH_ENC_GEN | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_ENC_LOAD | NEH_KEY192) : (NEH_ENC_LOAD | NEH_KEY256))\r\n\r\n#define neh_dec_gen_key(x) ((x) == 128 ? (NEH_DEC_GEN | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_DEC_GEN | NEH_KEY192) : (NEH_DEC_GEN | NEH_KEY256))\r\n\r\n#define neh_dec_load_key(x) ((x) == 128 ? (NEH_DEC_LOAD | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_DEC_LOAD | NEH_KEY192) : (NEH_DEC_LOAD | NEH_KEY256))\r\n\r\n#define neh_dec_hybrid_key(x) ((x) == 128 ? (NEH_DEC_GEN | NEH_KEY128) : \\\r\n (x) == 192 ? (NEH_DEC_LOAD | NEH_KEY192) : (NEH_DEC_LOAD | NEH_KEY256))\r\n\r\n#if defined( _MSC_VER ) && ( _MSC_VER > 1200 )\r\n#define aligned_auto(type, name, no, stride) __declspec(align(stride)) type name[no]\r\n#else\r\n#define aligned_auto(type, name, no, stride) \\\r\n unsigned char _##name[no * sizeof(type) + stride]; \\\r\n type *name = (type*)(16 * ((((unsigned long)(_##name)) + stride - 1) / stride))\r\n#endif\r\n\r\n#if defined( _MSC_VER ) && ( _MSC_VER > 1200 )\r\n#define aligned_array(type, name, no, stride) __declspec(align(stride)) type name[no]\r\n#elif defined( __GNUC__ )\r\n#define aligned_array(type, name, no, stride) type name[no] __attribute__ ((aligned(stride)))\r\n#else\r\n#define aligned_array(type, name, no, stride) type name[no]\r\n#endif\r\n\r\n/* VIA ACE codeword */\r\n\r\nstatic unsigned char via_flags = 0;\r\n\r\n#if defined ( _MSC_VER ) && ( _MSC_VER > 800 )\r\n\r\n#define NEH_REKEY __asm pushfd __asm popfd\r\n#define NEH_AES __asm _emit 0xf3 __asm _emit 0x0f __asm _emit 0xa7\r\n#define NEH_ECB NEH_AES __asm _emit 0xc8\r\n#define NEH_CBC NEH_AES __asm _emit 0xd0\r\n#define NEH_CFB NEH_AES __asm _emit 0xe0\r\n#define NEH_OFB NEH_AES __asm _emit 0xe8\r\n#define NEH_RNG __asm _emit 0x0f __asm _emit 0xa7 __asm _emit 0xc0\r\n\r\nINLINE int has_cpuid(void)\r\n{ char ret_value;\r\n __asm\r\n { pushfd /* save EFLAGS register */\r\n mov eax,[esp] /* copy it to eax */\r\n mov edx,0x00200000 /* CPUID bit position */\r\n xor eax,edx /* toggle the CPUID bit */\r\n push eax /* attempt to set EFLAGS to */\r\n popfd /* the new value */\r\n pushfd /* get the new EFLAGS value */\r\n pop eax /* into eax */\r\n xor eax,[esp] /* xor with original value */\r\n and eax,edx /* has CPUID bit changed? */\r\n setne al /* set to 1 if we have been */\r\n mov ret_value,al /* able to change it */\r\n popfd /* restore original EFLAGS */\r\n }\r\n return (int)ret_value;\r\n}\r\n\r\nINLINE int is_via_cpu(void)\r\n{ char ret_value;\r\n __asm\r\n { push ebx\r\n xor eax,eax /* use CPUID to get vendor */\r\n cpuid /* identity string */\r\n xor eax,eax /* is it \"CentaurHauls\" ? */\r\n sub ebx,0x746e6543 /* 'Cent' */\r\n or eax,ebx\r\n sub edx,0x48727561 /* 'aurH' */\r\n or eax,edx\r\n sub ecx,0x736c7561 /* 'auls' */\r\n or eax,ecx\r\n sete al /* set to 1 if it is VIA ID */\r\n mov dl,NEH_CPU_READ /* mark CPU type as read */\r\n or dl,al /* & store result in flags */\r\n mov [via_flags],dl /* set VIA detected flag */\r\n mov ret_value,al /* able to change it */\r\n pop ebx\r\n }\r\n return (int)ret_value;\r\n}\r\n\r\nINLINE int read_via_flags(void)\r\n{ char ret_value = 0;\r\n __asm\r\n { mov eax,0xC0000000 /* Centaur extended CPUID */\r\n cpuid\r\n mov edx,0xc0000001 /* >= 0xc0000001 if support */\r\n cmp eax,edx /* for VIA extended feature */\r\n jnae no_rng /* flags is available */\r\n mov eax,edx /* read Centaur extended */\r\n cpuid /* feature flags */\r\n mov eax,NEH_FLAGS_MASK /* mask out and save */\r\n and eax,edx /* the RNG and ACE flags */\r\n or [via_flags],al /* present & enabled flags */\r\n mov ret_value,al /* able to change it */\r\nno_rng:\r\n }\r\n return (int)ret_value;\r\n}\r\n\r\nINLINE unsigned int via_rng_in(void *buf)\r\n{ char ret_value = 0x1f;\r\n __asm\r\n { push edi\r\n mov edi,buf /* input buffer address */\r\n xor edx,edx /* try to fetch 8 bytes */\r\n NEH_RNG /* do RNG read operation */\r\n and ret_value,al /* count of bytes returned */\r\n pop edi\r\n }\r\n return (int)ret_value;\r\n}\r\n\r\nINLINE void via_ecb_op5(\r\n const void *k, const void *c, const void *s, void *d, int l)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n NEH_ECB\r\n pop ebx\r\n }\r\n}\r\n\r\nINLINE void via_cbc_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n mov eax, (v)\r\n NEH_CBC\r\n pop ebx\r\n }\r\n}\r\n\r\nINLINE void via_cbc_op7(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v, void *w)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n mov eax, (v)\r\n NEH_CBC\r\n mov esi, eax\r\n mov edi, (w)\r\n movsd\r\n movsd\r\n movsd\r\n movsd\r\n pop ebx\r\n }\r\n}\r\n\r\nINLINE void via_cfb_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n mov eax, (v)\r\n NEH_CFB\r\n pop ebx\r\n }\r\n}\r\n\r\nINLINE void via_cfb_op7(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v, void *w)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n mov eax, (v)\r\n NEH_CFB\r\n mov esi, eax\r\n mov edi, (w)\r\n movsd\r\n movsd\r\n movsd\r\n movsd\r\n pop ebx\r\n }\r\n}\r\n\r\nINLINE void via_ofb_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{ __asm\r\n { push ebx\r\n NEH_REKEY\r\n mov ebx, (k)\r\n mov edx, (c)\r\n mov esi, (s)\r\n mov edi, (d)\r\n mov ecx, (l)\r\n mov eax, (v)\r\n NEH_OFB\r\n pop ebx\r\n }\r\n}\r\n\r\n#elif defined( __GNUC__ )\r\n\r\n#define NEH_REKEY asm(\"pushfl\\n popfl\\n\\t\")\r\n#define NEH_ECB asm(\".byte 0xf3, 0x0f, 0xa7, 0xc8\\n\\t\")\r\n#define NEH_CBC asm(\".byte 0xf3, 0x0f, 0xa7, 0xd0\\n\\t\")\r\n#define NEH_CFB asm(\".byte 0xf3, 0x0f, 0xa7, 0xe0\\n\\t\")\r\n#define NEH_OFB asm(\".byte 0xf3, 0x0f, 0xa7, 0xe8\\n\\t\")\r\n#define NEH_RNG asm(\".byte 0x0f, 0xa7, 0xc0\\n\\t\");\r\n\r\nINLINE int has_cpuid(void)\r\n{ int val;\r\n asm(\"pushfl\\n\\t\");\r\n asm(\"movl 0(%esp),%eax\\n\\t\");\r\n asm(\"xor $0x00200000,%eax\\n\\t\");\r\n asm(\"pushl %eax\\n\\t\");\r\n asm(\"popfl\\n\\t\");\r\n asm(\"pushfl\\n\\t\");\r\n asm(\"popl %eax\\n\\t\");\r\n asm(\"xorl 0(%esp),%edx\\n\\t\");\r\n asm(\"andl $0x00200000,%eax\\n\\t\");\r\n asm(\"movl %%eax,%0\\n\\t\" : \"=m\" (val));\r\n asm(\"popfl\\n\\t\");\r\n return val ? 1 : 0;\r\n}\r\n\r\nINLINE int is_via_cpu(void)\r\n{ int val;\r\n asm(\"pushl %ebx\\n\\t\");\r\n asm(\"xorl %eax,%eax\\n\\t\");\r\n asm(\"cpuid\\n\\t\");\r\n asm(\"xorl %eax,%eax\\n\\t\");\r\n asm(\"subl $0x746e6543,%ebx\\n\\t\");\r\n asm(\"orl %ebx,%eax\\n\\t\");\r\n asm(\"subl $0x48727561,%edx\\n\\t\");\r\n asm(\"orl %edx,%eax\\n\\t\");\r\n asm(\"subl $0x736c7561,%ecx\\n\\t\");\r\n asm(\"orl %ecx,%eax\\n\\t\");\r\n asm(\"movl %%eax,%0\\n\\t\" : \"=m\" (val));\r\n asm(\"popl %ebx\\n\\t\");\r\n val = (val ? 0 : 1);\r\n via_flags = (val | NEH_CPU_READ);\r\n return val;\r\n}\r\n\r\nINLINE int read_via_flags(void)\r\n{ unsigned char val;\r\n asm(\"movl $0xc0000000,%eax\\n\\t\");\r\n asm(\"cpuid\\n\\t\");\r\n asm(\"movl $0xc0000001,%edx\\n\\t\");\r\n asm(\"cmpl %edx,%eax\\n\\t\");\r\n asm(\"setae %al\\n\\t\");\r\n asm(\"movb %%al,%0\\n\\t\" : \"=m\" (val));\r\n if(!val) return 0;\r\n asm(\"movl $0xc0000001,%eax\\n\\t\");\r\n asm(\"cpuid\\n\\t\");\r\n asm(\"movb %%dl,%0\\n\\t\" : \"=m\" (val));\r\n val &= NEH_FLAGS_MASK;\r\n via_flags |= val;\r\n return (int) val;\r\n}\r\n\r\nINLINE int via_rng_in(void *buf)\r\n{ int val;\r\n asm(\"pushl %edi\\n\\t\");\r\n asm(\"movl %0,%%edi\\n\\t\" : : \"m\" (buf));\r\n asm(\"xorl %edx,%edx\\n\\t\");\r\n NEH_RNG\r\n asm(\"andl $0x0000001f,%eax\\n\\t\");\r\n asm(\"movl %%eax,%0\\n\\t\" : \"=m\" (val));\r\n asm(\"popl %edi\\n\\t\");\r\n return val;\r\n}\r\n\r\nINLINE volatile void via_ecb_op5(\r\n const void *k, const void *c, const void *s, void *d, int l)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n NEH_ECB;\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\nINLINE volatile void via_cbc_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n asm(\"movl %0, %%eax\\n\\t\" : : \"m\" (v));\r\n NEH_CBC;\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\nINLINE volatile void via_cbc_op7(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v, void *w)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n asm(\"movl %0, %%eax\\n\\t\" : : \"m\" (v));\r\n NEH_CBC;\r\n asm(\"movl %eax,%esi\\n\\t\");\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (w));\r\n asm(\"movsl; movsl; movsl; movsl\\n\\t\");\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\nINLINE volatile void via_cfb_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n asm(\"movl %0, %%eax\\n\\t\" : : \"m\" (v));\r\n NEH_CFB;\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\nINLINE volatile void via_cfb_op7(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v, void *w)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n asm(\"movl %0, %%eax\\n\\t\" : : \"m\" (v));\r\n NEH_CFB;\r\n asm(\"movl %eax,%esi\\n\\t\");\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (w));\r\n asm(\"movsl; movsl; movsl; movsl\\n\\t\");\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\nINLINE volatile void via_ofb_op6(\r\n const void *k, const void *c, const void *s, void *d, int l, void *v)\r\n{\r\n asm(\"pushl %ebx\\n\\t\");\r\n NEH_REKEY;\r\n asm(\"movl %0, %%ebx\\n\\t\" : : \"m\" (k));\r\n asm(\"movl %0, %%edx\\n\\t\" : : \"m\" (c));\r\n asm(\"movl %0, %%esi\\n\\t\" : : \"m\" (s));\r\n asm(\"movl %0, %%edi\\n\\t\" : : \"m\" (d));\r\n asm(\"movl %0, %%ecx\\n\\t\" : : \"m\" (l));\r\n asm(\"movl %0, %%eax\\n\\t\" : : \"m\" (v));\r\n NEH_OFB;\r\n asm(\"popl %ebx\\n\\t\");\r\n}\r\n\r\n#else\r\n#error VIA ACE is not available with this compiler\r\n#endif\r\n\r\nINLINE int via_ace_test(void)\r\n{\r\n return has_cpuid() && is_via_cpu() && ((read_via_flags() & NEH_ACE_FLAGS) == NEH_ACE_FLAGS);\r\n}\r\n\r\n#define VIA_ACE_AVAILABLE (((via_flags & NEH_ACE_FLAGS) == NEH_ACE_FLAGS) \\\r\n || (via_flags & NEH_CPU_READ) && (via_flags & NEH_CPU_IS_VIA) || via_ace_test())\r\n\r\nINLINE int via_rng_test(void)\r\n{\r\n return has_cpuid() && is_via_cpu() && ((read_via_flags() & NEH_RNG_FLAGS) == NEH_RNG_FLAGS);\r\n}\r\n\r\n#define VIA_RNG_AVAILABLE (((via_flags & NEH_RNG_FLAGS) == NEH_RNG_FLAGS) \\\r\n || (via_flags & NEH_CPU_READ) && (via_flags & NEH_CPU_IS_VIA) || via_rng_test())\r\n\r\nINLINE int read_via_rng(void *buf, int count)\r\n{ int nbr, max_reads, lcnt = count;\r\n unsigned char *p, *q;\r\n aligned_auto(unsigned char, bp, 64, 16);\r\n\r\n if(!VIA_RNG_AVAILABLE)\r\n return 0;\r\n\r\n do\r\n {\r\n max_reads = MAX_READ_ATTEMPTS;\r\n do\r\n nbr = via_rng_in(bp);\r\n while\r\n (nbr == 0 && --max_reads);\r\n\r\n lcnt -= nbr;\r\n p = (unsigned char*)buf; q = bp;\r\n while(nbr--)\r\n *p++ = *q++;\r\n }\r\n while\r\n (lcnt && max_reads);\r\n\r\n return count - lcnt;\r\n}\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/aescrypt.c",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n*/\r\n\r\n#include \"aesopt.h\"\r\n#include \"aestab.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#define si(y,x,k,c) (s(y,c) = word_in(x, c) ^ (k)[c])\r\n#define so(y,x,c) word_out(y, c, s(x,c))\r\n\r\n#if defined(ARRAYS)\r\n#define locals(y,x) x[4],y[4]\r\n#else\r\n#define locals(y,x) x##0,x##1,x##2,x##3,y##0,y##1,y##2,y##3\r\n#endif\r\n\r\n#define l_copy(y, x) s(y,0) = s(x,0); s(y,1) = s(x,1); \\\r\n s(y,2) = s(x,2); s(y,3) = s(x,3);\r\n#define state_in(y,x,k) si(y,x,k,0); si(y,x,k,1); si(y,x,k,2); si(y,x,k,3)\r\n#define state_out(y,x) so(y,x,0); so(y,x,1); so(y,x,2); so(y,x,3)\r\n#define round(rm,y,x,k) rm(y,x,k,0); rm(y,x,k,1); rm(y,x,k,2); rm(y,x,k,3)\r\n\r\n#if ( FUNCS_IN_C & ENCRYPTION_IN_C )\r\n\r\n/* Visual C++ .Net v7.1 provides the fastest encryption code when using\r\n Pentium optimiation with small code but this is poor for decryption\r\n so we need to control this with the following VC++ pragmas\r\n*/\r\n\r\n#if defined( _MSC_VER ) && !defined( _WIN64 )\r\n#pragma optimize( \"s\", on )\r\n#endif\r\n\r\n/* Given the column (c) of the output state variable, the following\r\n macros give the input state variables which are needed in its\r\n computation for each row (r) of the state. All the alternative\r\n macros give the same end values but expand into different ways\r\n of calculating these values. In particular the complex macro\r\n used for dynamically variable block sizes is designed to expand\r\n to a compile time constant whenever possible but will expand to\r\n conditional clauses on some branches (I am grateful to Frank\r\n Yellin for this construction)\r\n*/\r\n\r\n#define fwd_var(x,r,c)\\\r\n ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\\\r\n : r == 1 ? ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0))\\\r\n : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\\\r\n : ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2)))\r\n\r\n#if defined(FT4_SET)\r\n#undef dec_fmvars\r\n#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,n),fwd_var,rf1,c))\r\n#elif defined(FT1_SET)\r\n#undef dec_fmvars\r\n#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(f,n),fwd_var,rf1,c))\r\n#else\r\n#define fwd_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ fwd_mcol(no_table(x,t_use(s,box),fwd_var,rf1,c)))\r\n#endif\r\n\r\n#if defined(FL4_SET)\r\n#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(f,l),fwd_var,rf1,c))\r\n#elif defined(FL1_SET)\r\n#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(f,l),fwd_var,rf1,c))\r\n#else\r\n#define fwd_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(s,box),fwd_var,rf1,c))\r\n#endif\r\n\r\nAES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out, const aes_encrypt_ctx cx[1])\r\n{ uint_32t locals(b0, b1);\r\n const uint_32t *kp;\r\n#if defined( dec_fmvars )\r\n dec_fmvars; /* declare variables for fwd_mcol() if needed */\r\n#endif\r\n\r\n if( cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16 )\r\n return EXIT_FAILURE;\r\n\r\n kp = cx->ks;\r\n state_in(b0, in, kp);\r\n\r\n#if (ENC_UNROLL == FULL)\r\n\r\n switch(cx->inf.b[0])\r\n {\r\n case 14 * 16:\r\n round(fwd_rnd, b1, b0, kp + 1 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 2 * N_COLS);\r\n kp += 2 * N_COLS;\r\n case 12 * 16:\r\n round(fwd_rnd, b1, b0, kp + 1 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 2 * N_COLS);\r\n kp += 2 * N_COLS;\r\n case 10 * 16:\r\n round(fwd_rnd, b1, b0, kp + 1 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 2 * N_COLS);\r\n round(fwd_rnd, b1, b0, kp + 3 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 4 * N_COLS);\r\n round(fwd_rnd, b1, b0, kp + 5 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 6 * N_COLS);\r\n round(fwd_rnd, b1, b0, kp + 7 * N_COLS);\r\n round(fwd_rnd, b0, b1, kp + 8 * N_COLS);\r\n round(fwd_rnd, b1, b0, kp + 9 * N_COLS);\r\n round(fwd_lrnd, b0, b1, kp +10 * N_COLS);\r\n }\r\n\r\n#else\r\n\r\n#if (ENC_UNROLL == PARTIAL)\r\n { uint_32t rnd;\r\n for(rnd = 0; rnd < (cx->inf.b[0] >> 5) - 1; ++rnd)\r\n {\r\n kp += N_COLS;\r\n round(fwd_rnd, b1, b0, kp);\r\n kp += N_COLS;\r\n round(fwd_rnd, b0, b1, kp);\r\n }\r\n kp += N_COLS;\r\n round(fwd_rnd, b1, b0, kp);\r\n#else\r\n { uint_32t rnd;\r\n for(rnd = 0; rnd < (cx->inf.b[0] >> 4) - 1; ++rnd)\r\n {\r\n kp += N_COLS;\r\n round(fwd_rnd, b1, b0, kp);\r\n l_copy(b0, b1);\r\n }\r\n#endif\r\n kp += N_COLS;\r\n round(fwd_lrnd, b0, b1, kp);\r\n }\r\n#endif\r\n\r\n state_out(out, b0);\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if ( FUNCS_IN_C & DECRYPTION_IN_C)\r\n\r\n/* Visual C++ .Net v7.1 provides the fastest encryption code when using\r\n Pentium optimiation with small code but this is poor for decryption\r\n so we need to control this with the following VC++ pragmas\r\n*/\r\n\r\n#if defined( _MSC_VER ) && !defined( _WIN64 )\r\n#pragma optimize( \"t\", on )\r\n#endif\r\n\r\n/* Given the column (c) of the output state variable, the following\r\n macros give the input state variables which are needed in its\r\n computation for each row (r) of the state. All the alternative\r\n macros give the same end values but expand into different ways\r\n of calculating these values. In particular the complex macro\r\n used for dynamically variable block sizes is designed to expand\r\n to a compile time constant whenever possible but will expand to\r\n conditional clauses on some branches (I am grateful to Frank\r\n Yellin for this construction)\r\n*/\r\n\r\n#define inv_var(x,r,c)\\\r\n ( r == 0 ? ( c == 0 ? s(x,0) : c == 1 ? s(x,1) : c == 2 ? s(x,2) : s(x,3))\\\r\n : r == 1 ? ( c == 0 ? s(x,3) : c == 1 ? s(x,0) : c == 2 ? s(x,1) : s(x,2))\\\r\n : r == 2 ? ( c == 0 ? s(x,2) : c == 1 ? s(x,3) : c == 2 ? s(x,0) : s(x,1))\\\r\n : ( c == 0 ? s(x,1) : c == 1 ? s(x,2) : c == 2 ? s(x,3) : s(x,0)))\r\n\r\n#if defined(IT4_SET)\r\n#undef dec_imvars\r\n#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,n),inv_var,rf1,c))\r\n#elif defined(IT1_SET)\r\n#undef dec_imvars\r\n#define inv_rnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,upr,t_use(i,n),inv_var,rf1,c))\r\n#else\r\n#define inv_rnd(y,x,k,c) (s(y,c) = inv_mcol((k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c)))\r\n#endif\r\n\r\n#if defined(IL4_SET)\r\n#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ four_tables(x,t_use(i,l),inv_var,rf1,c))\r\n#elif defined(IL1_SET)\r\n#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ one_table(x,ups,t_use(i,l),inv_var,rf1,c))\r\n#else\r\n#define inv_lrnd(y,x,k,c) (s(y,c) = (k)[c] ^ no_table(x,t_use(i,box),inv_var,rf1,c))\r\n#endif\r\n\r\n/* This code can work with the decryption key schedule in the */\r\n/* order that is used for encrytpion (where the 1st decryption */\r\n/* round key is at the high end ot the schedule) or with a key */\r\n/* schedule that has been reversed to put the 1st decryption */\r\n/* round key at the low end of the schedule in memory (when */\r\n/* AES_REV_DKS is defined) */\r\n\r\n#ifdef AES_REV_DKS\r\n#define key_ofs 0\r\n#define rnd_key(n) (kp + n * N_COLS)\r\n#else\r\n#define key_ofs 1\r\n#define rnd_key(n) (kp - n * N_COLS)\r\n#endif\r\n\r\nAES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out, const aes_decrypt_ctx cx[1])\r\n{ uint_32t locals(b0, b1);\r\n#if defined( dec_imvars )\r\n dec_imvars; /* declare variables for inv_mcol() if needed */\r\n#endif\r\n const uint_32t *kp;\r\n\r\n if( cx->inf.b[0] != 10 * 16 && cx->inf.b[0] != 12 * 16 && cx->inf.b[0] != 14 * 16 )\r\n return EXIT_FAILURE;\r\n\r\n kp = cx->ks + (key_ofs ? (cx->inf.b[0] >> 2) : 0);\r\n state_in(b0, in, kp);\r\n\r\n#if (DEC_UNROLL == FULL)\r\n\r\n kp = cx->ks + (key_ofs ? 0 : (cx->inf.b[0] >> 2));\r\n switch(cx->inf.b[0])\r\n {\r\n case 14 * 16:\r\n round(inv_rnd, b1, b0, rnd_key(-13));\r\n round(inv_rnd, b0, b1, rnd_key(-12));\r\n case 12 * 16:\r\n round(inv_rnd, b1, b0, rnd_key(-11));\r\n round(inv_rnd, b0, b1, rnd_key(-10));\r\n case 10 * 16:\r\n round(inv_rnd, b1, b0, rnd_key(-9));\r\n round(inv_rnd, b0, b1, rnd_key(-8));\r\n round(inv_rnd, b1, b0, rnd_key(-7));\r\n round(inv_rnd, b0, b1, rnd_key(-6));\r\n round(inv_rnd, b1, b0, rnd_key(-5));\r\n round(inv_rnd, b0, b1, rnd_key(-4));\r\n round(inv_rnd, b1, b0, rnd_key(-3));\r\n round(inv_rnd, b0, b1, rnd_key(-2));\r\n round(inv_rnd, b1, b0, rnd_key(-1));\r\n round(inv_lrnd, b0, b1, rnd_key( 0));\r\n }\r\n\r\n#else\r\n\r\n#if (DEC_UNROLL == PARTIAL)\r\n { uint_32t rnd;\r\n for(rnd = 0; rnd < (cx->inf.b[0] >> 5) - 1; ++rnd)\r\n {\r\n kp = rnd_key(1);\r\n round(inv_rnd, b1, b0, kp);\r\n kp = rnd_key(1);\r\n round(inv_rnd, b0, b1, kp);\r\n }\r\n kp = rnd_key(1);\r\n round(inv_rnd, b1, b0, kp);\r\n#else\r\n { uint_32t rnd;\r\n for(rnd = 0; rnd < (cx->inf.b[0] >> 4) - 1; ++rnd)\r\n {\r\n kp = rnd_key(1);\r\n round(inv_rnd, b1, b0, kp);\r\n l_copy(b0, b1);\r\n }\r\n#endif\r\n kp = rnd_key(1);\r\n round(inv_lrnd, b0, b1, kp);\r\n }\r\n#endif\r\n\r\n state_out(out, b0);\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/aeskey.c",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n*/\r\n\r\n#include \"aesopt.h\"\r\n#include \"aestab.h\"\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n# include \"aes_via_ace.h\"\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* Initialise the key schedule from the user supplied key. The key\r\n length can be specified in bytes, with legal values of 16, 24\r\n and 32, or in bits, with legal values of 128, 192 and 256. These\r\n values correspond with Nk values of 4, 6 and 8 respectively.\r\n\r\n The following macros implement a single cycle in the key\r\n schedule generation process. The number of cycles needed\r\n for each cx->n_col and nk value is:\r\n\r\n nk = 4 5 6 7 8\r\n ------------------------------\r\n cx->n_col = 4 10 9 8 7 7\r\n cx->n_col = 5 14 11 10 9 9\r\n cx->n_col = 6 19 15 12 11 11\r\n cx->n_col = 7 21 19 16 13 14\r\n cx->n_col = 8 29 23 19 17 14\r\n*/\r\n\r\n#if defined( REDUCE_CODE_SIZE )\r\n# define ls_box ls_sub\r\n uint_32t ls_sub(const uint_32t t, const uint_32t n);\r\n# define inv_mcol im_sub\r\n uint_32t im_sub(const uint_32t x);\r\n# ifdef ENC_KS_UNROLL\r\n# undef ENC_KS_UNROLL\r\n# endif\r\n# ifdef DEC_KS_UNROLL\r\n# undef DEC_KS_UNROLL\r\n# endif\r\n#endif\r\n\r\n#if (FUNCS_IN_C & ENC_KEYING_IN_C)\r\n\r\n#if defined(AES_128) || defined( AES_VAR )\r\n\r\n#define ke4(k,i) \\\r\n{ k[4*(i)+4] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \\\r\n k[4*(i)+5] = ss[1] ^= ss[0]; \\\r\n k[4*(i)+6] = ss[2] ^= ss[1]; \\\r\n k[4*(i)+7] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\nAES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1])\r\n{ uint_32t ss[4];\r\n\r\n cx->ks[0] = ss[0] = word_in(key, 0);\r\n cx->ks[1] = ss[1] = word_in(key, 1);\r\n cx->ks[2] = ss[2] = word_in(key, 2);\r\n cx->ks[3] = ss[3] = word_in(key, 3);\r\n\r\n#ifdef ENC_KS_UNROLL\r\n ke4(cx->ks, 0); ke4(cx->ks, 1);\r\n ke4(cx->ks, 2); ke4(cx->ks, 3);\r\n ke4(cx->ks, 4); ke4(cx->ks, 5);\r\n ke4(cx->ks, 6); ke4(cx->ks, 7);\r\n ke4(cx->ks, 8);\r\n#else\r\n { uint_32t i;\r\n for(i = 0; i < 9; ++i)\r\n ke4(cx->ks, i);\r\n }\r\n#endif\r\n ke4(cx->ks, 9);\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 10 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(AES_192) || defined( AES_VAR )\r\n\r\n#define kef6(k,i) \\\r\n{ k[6*(i)+ 6] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \\\r\n k[6*(i)+ 7] = ss[1] ^= ss[0]; \\\r\n k[6*(i)+ 8] = ss[2] ^= ss[1]; \\\r\n k[6*(i)+ 9] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\n#define ke6(k,i) \\\r\n{ kef6(k,i); \\\r\n k[6*(i)+10] = ss[4] ^= ss[3]; \\\r\n k[6*(i)+11] = ss[5] ^= ss[4]; \\\r\n}\r\n\r\nAES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1])\r\n{ uint_32t ss[6];\r\n\r\n cx->ks[0] = ss[0] = word_in(key, 0);\r\n cx->ks[1] = ss[1] = word_in(key, 1);\r\n cx->ks[2] = ss[2] = word_in(key, 2);\r\n cx->ks[3] = ss[3] = word_in(key, 3);\r\n cx->ks[4] = ss[4] = word_in(key, 4);\r\n cx->ks[5] = ss[5] = word_in(key, 5);\r\n\r\n#ifdef ENC_KS_UNROLL\r\n ke6(cx->ks, 0); ke6(cx->ks, 1);\r\n ke6(cx->ks, 2); ke6(cx->ks, 3);\r\n ke6(cx->ks, 4); ke6(cx->ks, 5);\r\n ke6(cx->ks, 6);\r\n#else\r\n { uint_32t i;\r\n for(i = 0; i < 7; ++i)\r\n ke6(cx->ks, i);\r\n }\r\n#endif\r\n kef6(cx->ks, 7);\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 12 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(AES_256) || defined( AES_VAR )\r\n\r\n#define kef8(k,i) \\\r\n{ k[8*(i)+ 8] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \\\r\n k[8*(i)+ 9] = ss[1] ^= ss[0]; \\\r\n k[8*(i)+10] = ss[2] ^= ss[1]; \\\r\n k[8*(i)+11] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\n#define ke8(k,i) \\\r\n{ kef8(k,i); \\\r\n k[8*(i)+12] = ss[4] ^= ls_box(ss[3],0); \\\r\n k[8*(i)+13] = ss[5] ^= ss[4]; \\\r\n k[8*(i)+14] = ss[6] ^= ss[5]; \\\r\n k[8*(i)+15] = ss[7] ^= ss[6]; \\\r\n}\r\n\r\nAES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1])\r\n{ uint_32t ss[8];\r\n\r\n cx->ks[0] = ss[0] = word_in(key, 0);\r\n cx->ks[1] = ss[1] = word_in(key, 1);\r\n cx->ks[2] = ss[2] = word_in(key, 2);\r\n cx->ks[3] = ss[3] = word_in(key, 3);\r\n cx->ks[4] = ss[4] = word_in(key, 4);\r\n cx->ks[5] = ss[5] = word_in(key, 5);\r\n cx->ks[6] = ss[6] = word_in(key, 6);\r\n cx->ks[7] = ss[7] = word_in(key, 7);\r\n\r\n#ifdef ENC_KS_UNROLL\r\n ke8(cx->ks, 0); ke8(cx->ks, 1);\r\n ke8(cx->ks, 2); ke8(cx->ks, 3);\r\n ke8(cx->ks, 4); ke8(cx->ks, 5);\r\n#else\r\n { uint_32t i;\r\n for(i = 0; i < 6; ++i)\r\n ke8(cx->ks, i);\r\n }\r\n#endif\r\n kef8(cx->ks, 6);\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 14 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined( AES_VAR )\r\n\r\nAES_RETURN aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1])\r\n{ \r\n switch(key_len)\r\n {\r\n case 16: case 128: return aes_encrypt_key128(key, cx);\r\n case 24: case 192: return aes_encrypt_key192(key, cx);\r\n case 32: case 256: return aes_encrypt_key256(key, cx);\r\n default: return EXIT_FAILURE;\r\n }\r\n}\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n#if (FUNCS_IN_C & DEC_KEYING_IN_C)\r\n\r\n/* this is used to store the decryption round keys */\r\n/* in forward or reverse order */\r\n\r\n#ifdef AES_REV_DKS\r\n#define v(n,i) ((n) - (i) + 2 * ((i) & 3))\r\n#else\r\n#define v(n,i) (i)\r\n#endif\r\n\r\n#if DEC_ROUND == NO_TABLES\r\n#define ff(x) (x)\r\n#else\r\n#define ff(x) inv_mcol(x)\r\n#if defined( dec_imvars )\r\n#define d_vars dec_imvars\r\n#endif\r\n#endif\r\n\r\n#if defined(AES_128) || defined( AES_VAR )\r\n\r\n#define k4e(k,i) \\\r\n{ k[v(40,(4*(i))+4)] = ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; \\\r\n k[v(40,(4*(i))+5)] = ss[1] ^= ss[0]; \\\r\n k[v(40,(4*(i))+6)] = ss[2] ^= ss[1]; \\\r\n k[v(40,(4*(i))+7)] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\n#if 1\r\n\r\n#define kdf4(k,i) \\\r\n{ ss[0] = ss[0] ^ ss[2] ^ ss[1] ^ ss[3]; \\\r\n ss[1] = ss[1] ^ ss[3]; \\\r\n ss[2] = ss[2] ^ ss[3]; \\\r\n ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \\\r\n ss[i % 4] ^= ss[4]; \\\r\n ss[4] ^= k[v(40,(4*(i)))]; k[v(40,(4*(i))+4)] = ff(ss[4]); \\\r\n ss[4] ^= k[v(40,(4*(i))+1)]; k[v(40,(4*(i))+5)] = ff(ss[4]); \\\r\n ss[4] ^= k[v(40,(4*(i))+2)]; k[v(40,(4*(i))+6)] = ff(ss[4]); \\\r\n ss[4] ^= k[v(40,(4*(i))+3)]; k[v(40,(4*(i))+7)] = ff(ss[4]); \\\r\n}\r\n\r\n#define kd4(k,i) \\\r\n{ ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; \\\r\n ss[i % 4] ^= ss[4]; ss[4] = ff(ss[4]); \\\r\n k[v(40,(4*(i))+4)] = ss[4] ^= k[v(40,(4*(i)))]; \\\r\n k[v(40,(4*(i))+5)] = ss[4] ^= k[v(40,(4*(i))+1)]; \\\r\n k[v(40,(4*(i))+6)] = ss[4] ^= k[v(40,(4*(i))+2)]; \\\r\n k[v(40,(4*(i))+7)] = ss[4] ^= k[v(40,(4*(i))+3)]; \\\r\n}\r\n\r\n#define kdl4(k,i) \\\r\n{ ss[4] = ls_box(ss[(i+3) % 4], 3) ^ t_use(r,c)[i]; ss[i % 4] ^= ss[4]; \\\r\n k[v(40,(4*(i))+4)] = (ss[0] ^= ss[1]) ^ ss[2] ^ ss[3]; \\\r\n k[v(40,(4*(i))+5)] = ss[1] ^ ss[3]; \\\r\n k[v(40,(4*(i))+6)] = ss[0]; \\\r\n k[v(40,(4*(i))+7)] = ss[1]; \\\r\n}\r\n\r\n#else\r\n\r\n#define kdf4(k,i) \\\r\n{ ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ff(ss[0]); \\\r\n ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ff(ss[1]); \\\r\n ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ff(ss[2]); \\\r\n ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ff(ss[3]); \\\r\n}\r\n\r\n#define kd4(k,i) \\\r\n{ ss[4] = ls_box(ss[3],3) ^ t_use(r,c)[i]; \\\r\n ss[0] ^= ss[4]; ss[4] = ff(ss[4]); k[v(40,(4*(i))+ 4)] = ss[4] ^= k[v(40,(4*(i)))]; \\\r\n ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[4] ^= k[v(40,(4*(i))+ 1)]; \\\r\n ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[4] ^= k[v(40,(4*(i))+ 2)]; \\\r\n ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[4] ^= k[v(40,(4*(i))+ 3)]; \\\r\n}\r\n\r\n#define kdl4(k,i) \\\r\n{ ss[0] ^= ls_box(ss[3],3) ^ t_use(r,c)[i]; k[v(40,(4*(i))+ 4)] = ss[0]; \\\r\n ss[1] ^= ss[0]; k[v(40,(4*(i))+ 5)] = ss[1]; \\\r\n ss[2] ^= ss[1]; k[v(40,(4*(i))+ 6)] = ss[2]; \\\r\n ss[3] ^= ss[2]; k[v(40,(4*(i))+ 7)] = ss[3]; \\\r\n}\r\n\r\n#endif\r\n\r\nAES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1])\r\n{ uint_32t ss[5];\r\n#if defined( d_vars )\r\n d_vars;\r\n#endif\r\n cx->ks[v(40,(0))] = ss[0] = word_in(key, 0);\r\n cx->ks[v(40,(1))] = ss[1] = word_in(key, 1);\r\n cx->ks[v(40,(2))] = ss[2] = word_in(key, 2);\r\n cx->ks[v(40,(3))] = ss[3] = word_in(key, 3);\r\n\r\n#ifdef DEC_KS_UNROLL\r\n kdf4(cx->ks, 0); kd4(cx->ks, 1);\r\n kd4(cx->ks, 2); kd4(cx->ks, 3);\r\n kd4(cx->ks, 4); kd4(cx->ks, 5);\r\n kd4(cx->ks, 6); kd4(cx->ks, 7);\r\n kd4(cx->ks, 8); kdl4(cx->ks, 9);\r\n#else\r\n { uint_32t i;\r\n for(i = 0; i < 10; ++i)\r\n k4e(cx->ks, i);\r\n#if !(DEC_ROUND == NO_TABLES)\r\n for(i = N_COLS; i < 10 * N_COLS; ++i)\r\n cx->ks[i] = inv_mcol(cx->ks[i]);\r\n#endif\r\n }\r\n#endif\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 10 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(AES_192) || defined( AES_VAR )\r\n\r\n#define k6ef(k,i) \\\r\n{ k[v(48,(6*(i))+ 6)] = ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; \\\r\n k[v(48,(6*(i))+ 7)] = ss[1] ^= ss[0]; \\\r\n k[v(48,(6*(i))+ 8)] = ss[2] ^= ss[1]; \\\r\n k[v(48,(6*(i))+ 9)] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\n#define k6e(k,i) \\\r\n{ k6ef(k,i); \\\r\n k[v(48,(6*(i))+10)] = ss[4] ^= ss[3]; \\\r\n k[v(48,(6*(i))+11)] = ss[5] ^= ss[4]; \\\r\n}\r\n\r\n#define kdf6(k,i) \\\r\n{ ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ff(ss[0]); \\\r\n ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ff(ss[1]); \\\r\n ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ff(ss[2]); \\\r\n ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ff(ss[3]); \\\r\n ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ff(ss[4]); \\\r\n ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ff(ss[5]); \\\r\n}\r\n\r\n#define kd6(k,i) \\\r\n{ ss[6] = ls_box(ss[5],3) ^ t_use(r,c)[i]; \\\r\n ss[0] ^= ss[6]; ss[6] = ff(ss[6]); k[v(48,(6*(i))+ 6)] = ss[6] ^= k[v(48,(6*(i)))]; \\\r\n ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[6] ^= k[v(48,(6*(i))+ 1)]; \\\r\n ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[6] ^= k[v(48,(6*(i))+ 2)]; \\\r\n ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[6] ^= k[v(48,(6*(i))+ 3)]; \\\r\n ss[4] ^= ss[3]; k[v(48,(6*(i))+10)] = ss[6] ^= k[v(48,(6*(i))+ 4)]; \\\r\n ss[5] ^= ss[4]; k[v(48,(6*(i))+11)] = ss[6] ^= k[v(48,(6*(i))+ 5)]; \\\r\n}\r\n\r\n#define kdl6(k,i) \\\r\n{ ss[0] ^= ls_box(ss[5],3) ^ t_use(r,c)[i]; k[v(48,(6*(i))+ 6)] = ss[0]; \\\r\n ss[1] ^= ss[0]; k[v(48,(6*(i))+ 7)] = ss[1]; \\\r\n ss[2] ^= ss[1]; k[v(48,(6*(i))+ 8)] = ss[2]; \\\r\n ss[3] ^= ss[2]; k[v(48,(6*(i))+ 9)] = ss[3]; \\\r\n}\r\n\r\nAES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1])\r\n{ uint_32t ss[7];\r\n#if defined( d_vars )\r\n d_vars;\r\n#endif\r\n cx->ks[v(48,(0))] = ss[0] = word_in(key, 0);\r\n cx->ks[v(48,(1))] = ss[1] = word_in(key, 1);\r\n cx->ks[v(48,(2))] = ss[2] = word_in(key, 2);\r\n cx->ks[v(48,(3))] = ss[3] = word_in(key, 3);\r\n\r\n#ifdef DEC_KS_UNROLL\r\n cx->ks[v(48,(4))] = ff(ss[4] = word_in(key, 4));\r\n cx->ks[v(48,(5))] = ff(ss[5] = word_in(key, 5));\r\n kdf6(cx->ks, 0); kd6(cx->ks, 1);\r\n kd6(cx->ks, 2); kd6(cx->ks, 3);\r\n kd6(cx->ks, 4); kd6(cx->ks, 5);\r\n kd6(cx->ks, 6); kdl6(cx->ks, 7);\r\n#else\r\n cx->ks[v(48,(4))] = ss[4] = word_in(key, 4);\r\n cx->ks[v(48,(5))] = ss[5] = word_in(key, 5);\r\n { uint_32t i;\r\n\r\n for(i = 0; i < 7; ++i)\r\n k6e(cx->ks, i);\r\n k6ef(cx->ks, 7);\r\n#if !(DEC_ROUND == NO_TABLES)\r\n for(i = N_COLS; i < 12 * N_COLS; ++i)\r\n cx->ks[i] = inv_mcol(cx->ks[i]);\r\n#endif\r\n }\r\n#endif\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 12 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(AES_256) || defined( AES_VAR )\r\n\r\n#define k8ef(k,i) \\\r\n{ k[v(56,(8*(i))+ 8)] = ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; \\\r\n k[v(56,(8*(i))+ 9)] = ss[1] ^= ss[0]; \\\r\n k[v(56,(8*(i))+10)] = ss[2] ^= ss[1]; \\\r\n k[v(56,(8*(i))+11)] = ss[3] ^= ss[2]; \\\r\n}\r\n\r\n#define k8e(k,i) \\\r\n{ k8ef(k,i); \\\r\n k[v(56,(8*(i))+12)] = ss[4] ^= ls_box(ss[3],0); \\\r\n k[v(56,(8*(i))+13)] = ss[5] ^= ss[4]; \\\r\n k[v(56,(8*(i))+14)] = ss[6] ^= ss[5]; \\\r\n k[v(56,(8*(i))+15)] = ss[7] ^= ss[6]; \\\r\n}\r\n\r\n#define kdf8(k,i) \\\r\n{ ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ff(ss[0]); \\\r\n ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ff(ss[1]); \\\r\n ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ff(ss[2]); \\\r\n ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ff(ss[3]); \\\r\n ss[4] ^= ls_box(ss[3],0); k[v(56,(8*(i))+12)] = ff(ss[4]); \\\r\n ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ff(ss[5]); \\\r\n ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ff(ss[6]); \\\r\n ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ff(ss[7]); \\\r\n}\r\n\r\n#define kd8(k,i) \\\r\n{ ss[8] = ls_box(ss[7],3) ^ t_use(r,c)[i]; \\\r\n ss[0] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+ 8)] = ss[8] ^= k[v(56,(8*(i)))]; \\\r\n ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[8] ^= k[v(56,(8*(i))+ 1)]; \\\r\n ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[8] ^= k[v(56,(8*(i))+ 2)]; \\\r\n ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[8] ^= k[v(56,(8*(i))+ 3)]; \\\r\n ss[8] = ls_box(ss[3],0); \\\r\n ss[4] ^= ss[8]; ss[8] = ff(ss[8]); k[v(56,(8*(i))+12)] = ss[8] ^= k[v(56,(8*(i))+ 4)]; \\\r\n ss[5] ^= ss[4]; k[v(56,(8*(i))+13)] = ss[8] ^= k[v(56,(8*(i))+ 5)]; \\\r\n ss[6] ^= ss[5]; k[v(56,(8*(i))+14)] = ss[8] ^= k[v(56,(8*(i))+ 6)]; \\\r\n ss[7] ^= ss[6]; k[v(56,(8*(i))+15)] = ss[8] ^= k[v(56,(8*(i))+ 7)]; \\\r\n}\r\n\r\n#define kdl8(k,i) \\\r\n{ ss[0] ^= ls_box(ss[7],3) ^ t_use(r,c)[i]; k[v(56,(8*(i))+ 8)] = ss[0]; \\\r\n ss[1] ^= ss[0]; k[v(56,(8*(i))+ 9)] = ss[1]; \\\r\n ss[2] ^= ss[1]; k[v(56,(8*(i))+10)] = ss[2]; \\\r\n ss[3] ^= ss[2]; k[v(56,(8*(i))+11)] = ss[3]; \\\r\n}\r\n\r\nAES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1])\r\n{ uint_32t ss[9];\r\n#if defined( d_vars )\r\n d_vars;\r\n#endif\r\n cx->ks[v(56,(0))] = ss[0] = word_in(key, 0);\r\n cx->ks[v(56,(1))] = ss[1] = word_in(key, 1);\r\n cx->ks[v(56,(2))] = ss[2] = word_in(key, 2);\r\n cx->ks[v(56,(3))] = ss[3] = word_in(key, 3);\r\n\r\n#ifdef DEC_KS_UNROLL\r\n cx->ks[v(56,(4))] = ff(ss[4] = word_in(key, 4));\r\n cx->ks[v(56,(5))] = ff(ss[5] = word_in(key, 5));\r\n cx->ks[v(56,(6))] = ff(ss[6] = word_in(key, 6));\r\n cx->ks[v(56,(7))] = ff(ss[7] = word_in(key, 7));\r\n kdf8(cx->ks, 0); kd8(cx->ks, 1);\r\n kd8(cx->ks, 2); kd8(cx->ks, 3);\r\n kd8(cx->ks, 4); kd8(cx->ks, 5);\r\n kdl8(cx->ks, 6);\r\n#else\r\n cx->ks[v(56,(4))] = ss[4] = word_in(key, 4);\r\n cx->ks[v(56,(5))] = ss[5] = word_in(key, 5);\r\n cx->ks[v(56,(6))] = ss[6] = word_in(key, 6);\r\n cx->ks[v(56,(7))] = ss[7] = word_in(key, 7);\r\n { uint_32t i;\r\n\r\n for(i = 0; i < 6; ++i)\r\n k8e(cx->ks, i);\r\n k8ef(cx->ks, 6);\r\n#if !(DEC_ROUND == NO_TABLES)\r\n for(i = N_COLS; i < 14 * N_COLS; ++i)\r\n cx->ks[i] = inv_mcol(cx->ks[i]);\r\n#endif\r\n }\r\n#endif\r\n cx->inf.l = 0;\r\n cx->inf.b[0] = 14 * 16;\r\n\r\n#ifdef USE_VIA_ACE_IF_PRESENT\r\n if(VIA_ACE_AVAILABLE)\r\n cx->inf.b[1] = 0xff;\r\n#endif\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined( AES_VAR )\r\n\r\nAES_RETURN aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1])\r\n{\r\n switch(key_len)\r\n {\r\n case 16: case 128: return aes_decrypt_key128(key, cx);\r\n case 24: case 192: return aes_decrypt_key192(key, cx);\r\n case 32: case 256: return aes_decrypt_key256(key, cx);\r\n default: return EXIT_FAILURE;\r\n }\r\n}\r\n\r\n#endif\r\n\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/aesopt.h",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n\r\n This file contains the compilation options for AES (Rijndael) and code\r\n that is common across encryption, key scheduling and table generation.\r\n\r\n OPERATION\r\n\r\n These source code files implement the AES algorithm Rijndael designed by\r\n Joan Daemen and Vincent Rijmen. This version is designed for the standard\r\n block size of 16 bytes and for key sizes of 128, 192 and 256 bits (16, 24\r\n and 32 bytes).\r\n\r\n This version is designed for flexibility and speed using operations on\r\n 32-bit words rather than operations on bytes. It can be compiled with\r\n either big or little endian internal byte order but is faster when the\r\n native byte order for the processor is used.\r\n\r\n THE CIPHER INTERFACE\r\n\r\n The cipher interface is implemented as an array of bytes in which lower\r\n AES bit sequence indexes map to higher numeric significance within bytes.\r\n\r\n uint_8t (an unsigned 8-bit type)\r\n uint_32t (an unsigned 32-bit type)\r\n struct aes_encrypt_ctx (structure for the cipher encryption context)\r\n struct aes_decrypt_ctx (structure for the cipher decryption context)\r\n AES_RETURN the function return type\r\n\r\n C subroutine calls:\r\n\r\n AES_RETURN aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n AES_RETURN aes_encrypt_key192(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n AES_RETURN aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1]);\r\n AES_RETURN aes_encrypt(const unsigned char *in, unsigned char *out,\r\n const aes_encrypt_ctx cx[1]);\r\n\r\n AES_RETURN aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n AES_RETURN aes_decrypt_key192(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n AES_RETURN aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1]);\r\n AES_RETURN aes_decrypt(const unsigned char *in, unsigned char *out,\r\n const aes_decrypt_ctx cx[1]);\r\n\r\n IMPORTANT NOTE: If you are using this C interface with dynamic tables make sure that\r\n you call aes_init() before AES is used so that the tables are initialised.\r\n\r\n C++ aes class subroutines:\r\n\r\n Class AESencrypt for encryption\r\n\r\n Construtors:\r\n AESencrypt(void)\r\n AESencrypt(const unsigned char *key) - 128 bit key\r\n Members:\r\n AES_RETURN key128(const unsigned char *key)\r\n AES_RETURN key192(const unsigned char *key)\r\n AES_RETURN key256(const unsigned char *key)\r\n AES_RETURN encrypt(const unsigned char *in, unsigned char *out) const\r\n\r\n Class AESdecrypt for encryption\r\n Construtors:\r\n AESdecrypt(void)\r\n AESdecrypt(const unsigned char *key) - 128 bit key\r\n Members:\r\n AES_RETURN key128(const unsigned char *key)\r\n AES_RETURN key192(const unsigned char *key)\r\n AES_RETURN key256(const unsigned char *key)\r\n AES_RETURN decrypt(const unsigned char *in, unsigned char *out) const\r\n*/\r\n\r\n#if !defined( _AESOPT_H )\r\n#define _AESOPT_H\r\n\r\n#if defined( __cplusplus )\r\n#include \"aescpp.h\"\r\n#else\r\n#include \"aes.h\"\r\n#endif\r\n\r\n/* PLATFORM SPECIFIC INCLUDES */\r\n\r\n#include \"brg_endian.h\"\r\n\r\n/* CONFIGURATION - THE USE OF DEFINES\r\n\r\n Later in this section there are a number of defines that control the\r\n operation of the code. In each section, the purpose of each define is\r\n explained so that the relevant form can be included or excluded by\r\n setting either 1's or 0's respectively on the branches of the related\r\n #if clauses. The following local defines should not be changed.\r\n*/\r\n\r\n#define ENCRYPTION_IN_C 1\r\n#define DECRYPTION_IN_C 2\r\n#define ENC_KEYING_IN_C 4\r\n#define DEC_KEYING_IN_C 8\r\n\r\n#define NO_TABLES 0\r\n#define ONE_TABLE 1\r\n#define FOUR_TABLES 4\r\n#define NONE 0\r\n#define PARTIAL 1\r\n#define FULL 2\r\n\r\n/* --- START OF USER CONFIGURED OPTIONS --- */\r\n\r\n/* 1. BYTE ORDER WITHIN 32 BIT WORDS\r\n\r\n The fundamental data processing units in Rijndael are 8-bit bytes. The\r\n input, output and key input are all enumerated arrays of bytes in which\r\n bytes are numbered starting at zero and increasing to one less than the\r\n number of bytes in the array in question. This enumeration is only used\r\n for naming bytes and does not imply any adjacency or order relationship\r\n from one byte to another. When these inputs and outputs are considered\r\n as bit sequences, bits 8*n to 8*n+7 of the bit sequence are mapped to\r\n byte[n] with bit 8n+i in the sequence mapped to bit 7-i within the byte.\r\n In this implementation bits are numbered from 0 to 7 starting at the\r\n numerically least significant end of each byte (bit n represents 2^n).\r\n\r\n However, Rijndael can be implemented more efficiently using 32-bit\r\n words by packing bytes into words so that bytes 4*n to 4*n+3 are placed\r\n into word[n]. While in principle these bytes can be assembled into words\r\n in any positions, this implementation only supports the two formats in\r\n which bytes in adjacent positions within words also have adjacent byte\r\n numbers. This order is called big-endian if the lowest numbered bytes\r\n in words have the highest numeric significance and little-endian if the\r\n opposite applies.\r\n\r\n This code can work in either order irrespective of the order used by the\r\n machine on which it runs. Normally the internal byte order will be set\r\n to the order of the processor on which the code is to be run but this\r\n define can be used to reverse this in special situations\r\n\r\n WARNING: Assembler code versions rely on PLATFORM_BYTE_ORDER being set.\r\n This define will hence be redefined later (in section 4) if necessary\r\n*/\r\n\r\n#if 1\r\n# define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER\r\n#elif 0\r\n# define ALGORITHM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#elif 0\r\n# define ALGORITHM_BYTE_ORDER IS_BIG_ENDIAN\r\n#else\r\n# error The algorithm byte order is not defined\r\n#endif\r\n\r\n/* 2. VIA ACE SUPPORT */\r\n\r\n#if !defined(__APPLE__) && defined( __GNUC__ ) && defined( __i386__ ) \\\r\n || defined( _WIN32 ) && defined( _M_IX86 ) \\\r\n && !(defined( _WIN64 ) || defined( _WIN32_WCE ) || defined( _MSC_VER ) && ( _MSC_VER <= 800 ))\r\n# define VIA_ACE_POSSIBLE\r\n#endif\r\n\r\n/* Define this option if support for the VIA ACE is required. This uses\r\n inline assembler instructions and is only implemented for the Microsoft,\r\n Intel and GCC compilers. If VIA ACE is known to be present, then defining\r\n ASSUME_VIA_ACE_PRESENT will remove the ordinary encryption/decryption\r\n code. If USE_VIA_ACE_IF_PRESENT is defined then VIA ACE will be used if\r\n it is detected (both present and enabled) but the normal AES code will\r\n also be present.\r\n\r\n When VIA ACE is to be used, all AES encryption contexts MUST be 16 byte\r\n aligned; other input/output buffers do not need to be 16 byte aligned\r\n but there are very large performance gains if this can be arranged.\r\n VIA ACE also requires the decryption key schedule to be in reverse\r\n order (which later checks below ensure).\r\n*/\r\n\r\n#if 1 && defined( VIA_ACE_POSSIBLE ) && !defined( USE_VIA_ACE_IF_PRESENT )\r\n# define USE_VIA_ACE_IF_PRESENT\r\n#endif\r\n\r\n#if 0 && defined( VIA_ACE_POSSIBLE ) && !defined( ASSUME_VIA_ACE_PRESENT )\r\n# define ASSUME_VIA_ACE_PRESENT\r\n# endif\r\n\r\n/* 3. ASSEMBLER SUPPORT\r\n\r\n This define (which can be on the command line) enables the use of the\r\n assembler code routines for encryption, decryption and key scheduling\r\n as follows:\r\n\r\n ASM_X86_V1C uses the assembler (aes_x86_v1.asm) with large tables for\r\n encryption and decryption and but with key scheduling in C\r\n ASM_X86_V2 uses assembler (aes_x86_v2.asm) with compressed tables for\r\n encryption, decryption and key scheduling\r\n ASM_X86_V2C uses assembler (aes_x86_v2.asm) with compressed tables for\r\n encryption and decryption and but with key scheduling in C\r\n ASM_AMD64_C uses assembler (aes_amd64.asm) with compressed tables for\r\n encryption and decryption and but with key scheduling in C\r\n\r\n Change one 'if 0' below to 'if 1' to select the version or define\r\n as a compilation option.\r\n*/\r\n\r\n#if 0 && !defined( ASM_X86_V1C )\r\n# define ASM_X86_V1C\r\n#elif 0 && !defined( ASM_X86_V2 )\r\n# define ASM_X86_V2\r\n#elif 0 && !defined( ASM_X86_V2C )\r\n# define ASM_X86_V2C\r\n#elif 0 && !defined( ASM_AMD64_C )\r\n# define ASM_AMD64_C\r\n#endif\r\n\r\n#if (defined ( ASM_X86_V1C ) || defined( ASM_X86_V2 ) || defined( ASM_X86_V2C )) \\\r\n && !defined( _M_IX86 ) || defined( ASM_AMD64_C ) && !defined( _M_X64 )\r\n# error Assembler code is only available for x86 and AMD64 systems\r\n#endif\r\n\r\n/* 4. FAST INPUT/OUTPUT OPERATIONS.\r\n\r\n On some machines it is possible to improve speed by transferring the\r\n bytes in the input and output arrays to and from the internal 32-bit\r\n variables by addressing these arrays as if they are arrays of 32-bit\r\n words. On some machines this will always be possible but there may\r\n be a large performance penalty if the byte arrays are not aligned on\r\n the normal word boundaries. On other machines this technique will\r\n lead to memory access errors when such 32-bit word accesses are not\r\n properly aligned. The option SAFE_IO avoids such problems but will\r\n often be slower on those machines that support misaligned access\r\n (especially so if care is taken to align the input and output byte\r\n arrays on 32-bit word boundaries). If SAFE_IO is not defined it is\r\n assumed that access to byte arrays as if they are arrays of 32-bit\r\n words will not cause problems when such accesses are misaligned.\r\n*/\r\n#if 1 && !defined( _MSC_VER )\r\n# define SAFE_IO\r\n#endif\r\n\r\n/* 5. LOOP UNROLLING\r\n\r\n The code for encryption and decrytpion cycles through a number of rounds\r\n that can be implemented either in a loop or by expanding the code into a\r\n long sequence of instructions, the latter producing a larger program but\r\n one that will often be much faster. The latter is called loop unrolling.\r\n There are also potential speed advantages in expanding two iterations in\r\n a loop with half the number of iterations, which is called partial loop\r\n unrolling. The following options allow partial or full loop unrolling\r\n to be set independently for encryption and decryption\r\n*/\r\n#if 1\r\n# define ENC_UNROLL FULL\r\n#elif 0\r\n# define ENC_UNROLL PARTIAL\r\n#else\r\n# define ENC_UNROLL NONE\r\n#endif\r\n\r\n#if 1\r\n# define DEC_UNROLL FULL\r\n#elif 0\r\n# define DEC_UNROLL PARTIAL\r\n#else\r\n# define DEC_UNROLL NONE\r\n#endif\r\n\r\n#if 1\r\n# define ENC_KS_UNROLL\r\n#endif\r\n\r\n#if 1\r\n# define DEC_KS_UNROLL\r\n#endif\r\n\r\n/* 6. FAST FINITE FIELD OPERATIONS\r\n\r\n If this section is included, tables are used to provide faster finite\r\n field arithmetic (this has no effect if FIXED_TABLES is defined).\r\n*/\r\n#if 1\r\n# define FF_TABLES\r\n#endif\r\n\r\n/* 7. INTERNAL STATE VARIABLE FORMAT\r\n\r\n The internal state of Rijndael is stored in a number of local 32-bit\r\n word varaibles which can be defined either as an array or as individual\r\n names variables. Include this section if you want to store these local\r\n varaibles in arrays. Otherwise individual local variables will be used.\r\n*/\r\n#if 1\r\n# define ARRAYS\r\n#endif\r\n\r\n/* 8. FIXED OR DYNAMIC TABLES\r\n\r\n When this section is included the tables used by the code are compiled\r\n statically into the binary file. Otherwise the subroutine aes_init()\r\n must be called to compute them before the code is first used.\r\n*/\r\n#if 1 && !(defined( _MSC_VER ) && ( _MSC_VER <= 800 ))\r\n# define FIXED_TABLES\r\n#endif\r\n\r\n/* 9. MASKING OR CASTING FROM LONGER VALUES TO BYTES\r\n\r\n In some systems it is better to mask longer values to extract bytes \r\n rather than using a cast. This option allows this choice.\r\n*/\r\n#if 0\r\n# define to_byte(x) ((uint_8t)(x))\r\n#else\r\n# define to_byte(x) ((x) & 0xff)\r\n#endif\r\n\r\n/* 10. TABLE ALIGNMENT\r\n\r\n On some sytsems speed will be improved by aligning the AES large lookup\r\n tables on particular boundaries. This define should be set to a power of\r\n two giving the desired alignment. It can be left undefined if alignment\r\n is not needed. This option is specific to the Microsft VC++ compiler -\r\n it seems to sometimes cause trouble for the VC++ version 6 compiler.\r\n*/\r\n\r\n#if 1 && defined( _MSC_VER ) && ( _MSC_VER >= 1300 )\r\n# define TABLE_ALIGN 32\r\n#endif\r\n\r\n/* 11. REDUCE CODE AND TABLE SIZE\r\n\r\n This replaces some expanded macros with function calls if AES_ASM_V2 or\r\n AES_ASM_V2C are defined\r\n*/\r\n\r\n#if 1 && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C ))\r\n# define REDUCE_CODE_SIZE\r\n#endif\r\n\r\n/* 12. TABLE OPTIONS\r\n\r\n This cipher proceeds by repeating in a number of cycles known as 'rounds'\r\n which are implemented by a round function which can optionally be speeded\r\n up using tables. The basic tables are each 256 32-bit words, with either\r\n one or four tables being required for each round function depending on\r\n how much speed is required. The encryption and decryption round functions\r\n are different and the last encryption and decrytpion round functions are\r\n different again making four different round functions in all.\r\n\r\n This means that:\r\n 1. Normal encryption and decryption rounds can each use either 0, 1\r\n or 4 tables and table spaces of 0, 1024 or 4096 bytes each.\r\n 2. The last encryption and decryption rounds can also use either 0, 1\r\n or 4 tables and table spaces of 0, 1024 or 4096 bytes each.\r\n\r\n Include or exclude the appropriate definitions below to set the number\r\n of tables used by this implementation.\r\n*/\r\n\r\n#if 1 /* set tables for the normal encryption round */\r\n# define ENC_ROUND FOUR_TABLES\r\n#elif 0\r\n# define ENC_ROUND ONE_TABLE\r\n#else\r\n# define ENC_ROUND NO_TABLES\r\n#endif\r\n\r\n#if 1 /* set tables for the last encryption round */\r\n# define LAST_ENC_ROUND FOUR_TABLES\r\n#elif 0\r\n# define LAST_ENC_ROUND ONE_TABLE\r\n#else\r\n# define LAST_ENC_ROUND NO_TABLES\r\n#endif\r\n\r\n#if 1 /* set tables for the normal decryption round */\r\n# define DEC_ROUND FOUR_TABLES\r\n#elif 0\r\n# define DEC_ROUND ONE_TABLE\r\n#else\r\n# define DEC_ROUND NO_TABLES\r\n#endif\r\n\r\n#if 1 /* set tables for the last decryption round */\r\n# define LAST_DEC_ROUND FOUR_TABLES\r\n#elif 0\r\n# define LAST_DEC_ROUND ONE_TABLE\r\n#else\r\n# define LAST_DEC_ROUND NO_TABLES\r\n#endif\r\n\r\n/* The decryption key schedule can be speeded up with tables in the same\r\n way that the round functions can. Include or exclude the following\r\n defines to set this requirement.\r\n*/\r\n#if 1\r\n# define KEY_SCHED FOUR_TABLES\r\n#elif 0\r\n# define KEY_SCHED ONE_TABLE\r\n#else\r\n# define KEY_SCHED NO_TABLES\r\n#endif\r\n\r\n/* ---- END OF USER CONFIGURED OPTIONS ---- */\r\n\r\n/* VIA ACE support is only available for VC++ and GCC */\r\n\r\n#if !defined( _MSC_VER ) && !defined( __GNUC__ )\r\n# if defined( ASSUME_VIA_ACE_PRESENT )\r\n# undef ASSUME_VIA_ACE_PRESENT\r\n# endif\r\n# if defined( USE_VIA_ACE_IF_PRESENT )\r\n# undef USE_VIA_ACE_IF_PRESENT\r\n# endif\r\n#endif\r\n\r\n#if defined( ASSUME_VIA_ACE_PRESENT ) && !defined( USE_VIA_ACE_IF_PRESENT )\r\n# define USE_VIA_ACE_IF_PRESENT\r\n#endif\r\n\r\n#if defined( USE_VIA_ACE_IF_PRESENT ) && !defined ( AES_REV_DKS )\r\n# define AES_REV_DKS\r\n#endif\r\n\r\n/* Assembler support requires the use of platform byte order */\r\n\r\n#if ( defined( ASM_X86_V1C ) || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C ) ) \\\r\n && (ALGORITHM_BYTE_ORDER != PLATFORM_BYTE_ORDER)\r\n# undef ALGORITHM_BYTE_ORDER\r\n# define ALGORITHM_BYTE_ORDER PLATFORM_BYTE_ORDER\r\n#endif\r\n\r\n/* In this implementation the columns of the state array are each held in\r\n 32-bit words. The state array can be held in various ways: in an array\r\n of words, in a number of individual word variables or in a number of\r\n processor registers. The following define maps a variable name x and\r\n a column number c to the way the state array variable is to be held.\r\n The first define below maps the state into an array x[c] whereas the\r\n second form maps the state into a number of individual variables x0,\r\n x1, etc. Another form could map individual state colums to machine\r\n register names.\r\n*/\r\n\r\n#if defined( ARRAYS )\r\n# define s(x,c) x[c]\r\n#else\r\n# define s(x,c) x##c\r\n#endif\r\n\r\n/* This implementation provides subroutines for encryption, decryption\r\n and for setting the three key lengths (separately) for encryption\r\n and decryption. Since not all functions are needed, masks are set\r\n up here to determine which will be implemented in C\r\n*/\r\n\r\n#if !defined( AES_ENCRYPT )\r\n# define EFUNCS_IN_C 0\r\n#elif defined( ASSUME_VIA_ACE_PRESENT ) || defined( ASM_X86_V1C ) \\\r\n || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C )\r\n# define EFUNCS_IN_C ENC_KEYING_IN_C\r\n#elif !defined( ASM_X86_V2 )\r\n# define EFUNCS_IN_C ( ENCRYPTION_IN_C | ENC_KEYING_IN_C )\r\n#else\r\n# define EFUNCS_IN_C 0\r\n#endif\r\n\r\n#if !defined( AES_DECRYPT )\r\n# define DFUNCS_IN_C 0\r\n#elif defined( ASSUME_VIA_ACE_PRESENT ) || defined( ASM_X86_V1C ) \\\r\n || defined( ASM_X86_V2C ) || defined( ASM_AMD64_C )\r\n# define DFUNCS_IN_C DEC_KEYING_IN_C\r\n#elif !defined( ASM_X86_V2 )\r\n# define DFUNCS_IN_C ( DECRYPTION_IN_C | DEC_KEYING_IN_C )\r\n#else\r\n# define DFUNCS_IN_C 0\r\n#endif\r\n\r\n#define FUNCS_IN_C ( EFUNCS_IN_C | DFUNCS_IN_C )\r\n\r\n/* END OF CONFIGURATION OPTIONS */\r\n\r\n#define RC_LENGTH (5 * (AES_BLOCK_SIZE / 4 - 2))\r\n\r\n/* Disable or report errors on some combinations of options */\r\n\r\n#if ENC_ROUND == NO_TABLES && LAST_ENC_ROUND != NO_TABLES\r\n# undef LAST_ENC_ROUND\r\n# define LAST_ENC_ROUND NO_TABLES\r\n#elif ENC_ROUND == ONE_TABLE && LAST_ENC_ROUND == FOUR_TABLES\r\n# undef LAST_ENC_ROUND\r\n# define LAST_ENC_ROUND ONE_TABLE\r\n#endif\r\n\r\n#if ENC_ROUND == NO_TABLES && ENC_UNROLL != NONE\r\n# undef ENC_UNROLL\r\n# define ENC_UNROLL NONE\r\n#endif\r\n\r\n#if DEC_ROUND == NO_TABLES && LAST_DEC_ROUND != NO_TABLES\r\n# undef LAST_DEC_ROUND\r\n# define LAST_DEC_ROUND NO_TABLES\r\n#elif DEC_ROUND == ONE_TABLE && LAST_DEC_ROUND == FOUR_TABLES\r\n# undef LAST_DEC_ROUND\r\n# define LAST_DEC_ROUND ONE_TABLE\r\n#endif\r\n\r\n#if DEC_ROUND == NO_TABLES && DEC_UNROLL != NONE\r\n# undef DEC_UNROLL\r\n# define DEC_UNROLL NONE\r\n#endif\r\n\r\n#if defined( bswap32 )\r\n# define aes_sw32 bswap32\r\n#elif defined( bswap_32 )\r\n# define aes_sw32 bswap_32\r\n#else\r\n# define brot(x,n) (((uint_32t)(x) << n) | ((uint_32t)(x) >> (32 - n)))\r\n# define aes_sw32(x) ((brot((x),8) & 0x00ff00ff) | (brot((x),24) & 0xff00ff00))\r\n#endif\r\n\r\n/* upr(x,n): rotates bytes within words by n positions, moving bytes to\r\n higher index positions with wrap around into low positions\r\n ups(x,n): moves bytes by n positions to higher index positions in\r\n words but without wrap around\r\n bval(x,n): extracts a byte from a word\r\n\r\n WARNING: The definitions given here are intended only for use with\r\n unsigned variables and with shift counts that are compile\r\n time constants\r\n*/\r\n\r\n#if ( ALGORITHM_BYTE_ORDER == IS_LITTLE_ENDIAN )\r\n# define upr(x,n) (((uint_32t)(x) << (8 * (n))) | ((uint_32t)(x) >> (32 - 8 * (n))))\r\n# define ups(x,n) ((uint_32t) (x) << (8 * (n)))\r\n# define bval(x,n) to_byte((x) >> (8 * (n)))\r\n# define bytes2word(b0, b1, b2, b3) \\\r\n (((uint_32t)(b3) << 24) | ((uint_32t)(b2) << 16) | ((uint_32t)(b1) << 8) | (b0))\r\n#endif\r\n\r\n#if ( ALGORITHM_BYTE_ORDER == IS_BIG_ENDIAN )\r\n# define upr(x,n) (((uint_32t)(x) >> (8 * (n))) | ((uint_32t)(x) << (32 - 8 * (n))))\r\n# define ups(x,n) ((uint_32t) (x) >> (8 * (n)))\r\n# define bval(x,n) to_byte((x) >> (24 - 8 * (n)))\r\n# define bytes2word(b0, b1, b2, b3) \\\r\n (((uint_32t)(b0) << 24) | ((uint_32t)(b1) << 16) | ((uint_32t)(b2) << 8) | (b3))\r\n#endif\r\n\r\n#if defined( SAFE_IO )\r\n# define word_in(x,c) bytes2word(((const uint_8t*)(x)+4*c)[0], ((const uint_8t*)(x)+4*c)[1], \\\r\n ((const uint_8t*)(x)+4*c)[2], ((const uint_8t*)(x)+4*c)[3])\r\n# define word_out(x,c,v) { ((uint_8t*)(x)+4*c)[0] = bval(v,0); ((uint_8t*)(x)+4*c)[1] = bval(v,1); \\\r\n ((uint_8t*)(x)+4*c)[2] = bval(v,2); ((uint_8t*)(x)+4*c)[3] = bval(v,3); }\r\n#elif ( ALGORITHM_BYTE_ORDER == PLATFORM_BYTE_ORDER )\r\n# define word_in(x,c) (*((uint_32t*)(x)+(c)))\r\n# define word_out(x,c,v) (*((uint_32t*)(x)+(c)) = (v))\r\n#else\r\n# define word_in(x,c) aes_sw32(*((uint_32t*)(x)+(c)))\r\n# define word_out(x,c,v) (*((uint_32t*)(x)+(c)) = aes_sw32(v))\r\n#endif\r\n\r\n/* the finite field modular polynomial and elements */\r\n\r\n#define WPOLY 0x011b\r\n#define BPOLY 0x1b\r\n\r\n/* multiply four bytes in GF(2^8) by 'x' {02} in parallel */\r\n\r\n#define gf_c1 0x80808080\r\n#define gf_c2 0x7f7f7f7f\r\n#define gf_mulx(x) ((((x) & gf_c2) << 1) ^ ((((x) & gf_c1) >> 7) * BPOLY))\r\n\r\n/* The following defines provide alternative definitions of gf_mulx that might\r\n give improved performance if a fast 32-bit multiply is not available. Note\r\n that a temporary variable u needs to be defined where gf_mulx is used.\r\n\r\n#define gf_mulx(x) (u = (x) & gf_c1, u |= (u >> 1), ((x) & gf_c2) << 1) ^ ((u >> 3) | (u >> 6))\r\n#define gf_c4 (0x01010101 * BPOLY)\r\n#define gf_mulx(x) (u = (x) & gf_c1, ((x) & gf_c2) << 1) ^ ((u - (u >> 7)) & gf_c4)\r\n*/\r\n\r\n/* Work out which tables are needed for the different options */\r\n\r\n#if defined( ASM_X86_V1C )\r\n# if defined( ENC_ROUND )\r\n# undef ENC_ROUND\r\n# endif\r\n# define ENC_ROUND FOUR_TABLES\r\n# if defined( LAST_ENC_ROUND )\r\n# undef LAST_ENC_ROUND\r\n# endif\r\n# define LAST_ENC_ROUND FOUR_TABLES\r\n# if defined( DEC_ROUND )\r\n# undef DEC_ROUND\r\n# endif\r\n# define DEC_ROUND FOUR_TABLES\r\n# if defined( LAST_DEC_ROUND )\r\n# undef LAST_DEC_ROUND\r\n# endif\r\n# define LAST_DEC_ROUND FOUR_TABLES\r\n# if defined( KEY_SCHED )\r\n# undef KEY_SCHED\r\n# define KEY_SCHED FOUR_TABLES\r\n# endif\r\n#endif\r\n\r\n#if ( FUNCS_IN_C & ENCRYPTION_IN_C ) || defined( ASM_X86_V1C )\r\n# if ENC_ROUND == ONE_TABLE\r\n# define FT1_SET\r\n# elif ENC_ROUND == FOUR_TABLES\r\n# define FT4_SET\r\n# else\r\n# define SBX_SET\r\n# endif\r\n# if LAST_ENC_ROUND == ONE_TABLE\r\n# define FL1_SET\r\n# elif LAST_ENC_ROUND == FOUR_TABLES\r\n# define FL4_SET\r\n# elif !defined( SBX_SET )\r\n# define SBX_SET\r\n# endif\r\n#endif\r\n\r\n#if ( FUNCS_IN_C & DECRYPTION_IN_C ) || defined( ASM_X86_V1C )\r\n# if DEC_ROUND == ONE_TABLE\r\n# define IT1_SET\r\n# elif DEC_ROUND == FOUR_TABLES\r\n# define IT4_SET\r\n# else\r\n# define ISB_SET\r\n# endif\r\n# if LAST_DEC_ROUND == ONE_TABLE\r\n# define IL1_SET\r\n# elif LAST_DEC_ROUND == FOUR_TABLES\r\n# define IL4_SET\r\n# elif !defined(ISB_SET)\r\n# define ISB_SET\r\n# endif\r\n#endif\r\n\r\n#if !(defined( REDUCE_CODE_SIZE ) && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C )))\r\n# if ((FUNCS_IN_C & ENC_KEYING_IN_C) || (FUNCS_IN_C & DEC_KEYING_IN_C))\r\n# if KEY_SCHED == ONE_TABLE\r\n# if !defined( FL1_SET ) && !defined( FL4_SET ) \r\n# define LS1_SET\r\n# endif\r\n# elif KEY_SCHED == FOUR_TABLES\r\n# if !defined( FL4_SET )\r\n# define LS4_SET\r\n# endif\r\n# elif !defined( SBX_SET )\r\n# define SBX_SET\r\n# endif\r\n# endif\r\n# if (FUNCS_IN_C & DEC_KEYING_IN_C)\r\n# if KEY_SCHED == ONE_TABLE\r\n# define IM1_SET\r\n# elif KEY_SCHED == FOUR_TABLES\r\n# define IM4_SET\r\n# elif !defined( SBX_SET )\r\n# define SBX_SET\r\n# endif\r\n# endif\r\n#endif\r\n\r\n/* generic definitions of Rijndael macros that use tables */\r\n\r\n#define no_table(x,box,vf,rf,c) bytes2word( \\\r\n box[bval(vf(x,0,c),rf(0,c))], \\\r\n box[bval(vf(x,1,c),rf(1,c))], \\\r\n box[bval(vf(x,2,c),rf(2,c))], \\\r\n box[bval(vf(x,3,c),rf(3,c))])\r\n\r\n#define one_table(x,op,tab,vf,rf,c) \\\r\n ( tab[bval(vf(x,0,c),rf(0,c))] \\\r\n ^ op(tab[bval(vf(x,1,c),rf(1,c))],1) \\\r\n ^ op(tab[bval(vf(x,2,c),rf(2,c))],2) \\\r\n ^ op(tab[bval(vf(x,3,c),rf(3,c))],3))\r\n\r\n#define four_tables(x,tab,vf,rf,c) \\\r\n ( tab[0][bval(vf(x,0,c),rf(0,c))] \\\r\n ^ tab[1][bval(vf(x,1,c),rf(1,c))] \\\r\n ^ tab[2][bval(vf(x,2,c),rf(2,c))] \\\r\n ^ tab[3][bval(vf(x,3,c),rf(3,c))])\r\n\r\n#define vf1(x,r,c) (x)\r\n#define rf1(r,c) (r)\r\n#define rf2(r,c) ((8+r-c)&3)\r\n\r\n/* perform forward and inverse column mix operation on four bytes in long word x in */\r\n/* parallel. NOTE: x must be a simple variable, NOT an expression in these macros. */\r\n\r\n#if !(defined( REDUCE_CODE_SIZE ) && (defined( ASM_X86_V2 ) || defined( ASM_X86_V2C ))) \r\n\r\n#if defined( FM4_SET ) /* not currently used */\r\n# define fwd_mcol(x) four_tables(x,t_use(f,m),vf1,rf1,0)\r\n#elif defined( FM1_SET ) /* not currently used */\r\n# define fwd_mcol(x) one_table(x,upr,t_use(f,m),vf1,rf1,0)\r\n#else\r\n# define dec_fmvars uint_32t g2\r\n# define fwd_mcol(x) (g2 = gf_mulx(x), g2 ^ upr((x) ^ g2, 3) ^ upr((x), 2) ^ upr((x), 1))\r\n#endif\r\n\r\n#if defined( IM4_SET )\r\n# define inv_mcol(x) four_tables(x,t_use(i,m),vf1,rf1,0)\r\n#elif defined( IM1_SET )\r\n# define inv_mcol(x) one_table(x,upr,t_use(i,m),vf1,rf1,0)\r\n#else\r\n# define dec_imvars uint_32t g2, g4, g9\r\n# define inv_mcol(x) (g2 = gf_mulx(x), g4 = gf_mulx(g2), g9 = (x) ^ gf_mulx(g4), g4 ^= g9, \\\r\n (x) ^ g2 ^ g4 ^ upr(g2 ^ g9, 3) ^ upr(g4, 2) ^ upr(g9, 1))\r\n#endif\r\n\r\n#if defined( FL4_SET )\r\n# define ls_box(x,c) four_tables(x,t_use(f,l),vf1,rf2,c)\r\n#elif defined( LS4_SET )\r\n# define ls_box(x,c) four_tables(x,t_use(l,s),vf1,rf2,c)\r\n#elif defined( FL1_SET )\r\n# define ls_box(x,c) one_table(x,upr,t_use(f,l),vf1,rf2,c)\r\n#elif defined( LS1_SET )\r\n# define ls_box(x,c) one_table(x,upr,t_use(l,s),vf1,rf2,c)\r\n#else\r\n# define ls_box(x,c) no_table(x,t_use(s,box),vf1,rf2,c)\r\n#endif\r\n\r\n#endif\r\n\r\n#if defined( ASM_X86_V1C ) && defined( AES_DECRYPT ) && !defined( ISB_SET )\r\n# define ISB_SET\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/aestab.c",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n*/\r\n\r\n#define DO_TABLES\r\n\r\n#include \"aes.h\"\r\n#include \"aesopt.h\"\r\n\r\n#if defined(FIXED_TABLES)\r\n\r\n#define sb_data(w) {\\\r\n w(0x63), w(0x7c), w(0x77), w(0x7b), w(0xf2), w(0x6b), w(0x6f), w(0xc5),\\\r\n w(0x30), w(0x01), w(0x67), w(0x2b), w(0xfe), w(0xd7), w(0xab), w(0x76),\\\r\n w(0xca), w(0x82), w(0xc9), w(0x7d), w(0xfa), w(0x59), w(0x47), w(0xf0),\\\r\n w(0xad), w(0xd4), w(0xa2), w(0xaf), w(0x9c), w(0xa4), w(0x72), w(0xc0),\\\r\n w(0xb7), w(0xfd), w(0x93), w(0x26), w(0x36), w(0x3f), w(0xf7), w(0xcc),\\\r\n w(0x34), w(0xa5), w(0xe5), w(0xf1), w(0x71), w(0xd8), w(0x31), w(0x15),\\\r\n w(0x04), w(0xc7), w(0x23), w(0xc3), w(0x18), w(0x96), w(0x05), w(0x9a),\\\r\n w(0x07), w(0x12), w(0x80), w(0xe2), w(0xeb), w(0x27), w(0xb2), w(0x75),\\\r\n w(0x09), w(0x83), w(0x2c), w(0x1a), w(0x1b), w(0x6e), w(0x5a), w(0xa0),\\\r\n w(0x52), w(0x3b), w(0xd6), w(0xb3), w(0x29), w(0xe3), w(0x2f), w(0x84),\\\r\n w(0x53), w(0xd1), w(0x00), w(0xed), w(0x20), w(0xfc), w(0xb1), w(0x5b),\\\r\n w(0x6a), w(0xcb), w(0xbe), w(0x39), w(0x4a), w(0x4c), w(0x58), w(0xcf),\\\r\n w(0xd0), w(0xef), w(0xaa), w(0xfb), w(0x43), w(0x4d), w(0x33), w(0x85),\\\r\n w(0x45), w(0xf9), w(0x02), w(0x7f), w(0x50), w(0x3c), w(0x9f), w(0xa8),\\\r\n w(0x51), w(0xa3), w(0x40), w(0x8f), w(0x92), w(0x9d), w(0x38), w(0xf5),\\\r\n w(0xbc), w(0xb6), w(0xda), w(0x21), w(0x10), w(0xff), w(0xf3), w(0xd2),\\\r\n w(0xcd), w(0x0c), w(0x13), w(0xec), w(0x5f), w(0x97), w(0x44), w(0x17),\\\r\n w(0xc4), w(0xa7), w(0x7e), w(0x3d), w(0x64), w(0x5d), w(0x19), w(0x73),\\\r\n w(0x60), w(0x81), w(0x4f), w(0xdc), w(0x22), w(0x2a), w(0x90), w(0x88),\\\r\n w(0x46), w(0xee), w(0xb8), w(0x14), w(0xde), w(0x5e), w(0x0b), w(0xdb),\\\r\n w(0xe0), w(0x32), w(0x3a), w(0x0a), w(0x49), w(0x06), w(0x24), w(0x5c),\\\r\n w(0xc2), w(0xd3), w(0xac), w(0x62), w(0x91), w(0x95), w(0xe4), w(0x79),\\\r\n w(0xe7), w(0xc8), w(0x37), w(0x6d), w(0x8d), w(0xd5), w(0x4e), w(0xa9),\\\r\n w(0x6c), w(0x56), w(0xf4), w(0xea), w(0x65), w(0x7a), w(0xae), w(0x08),\\\r\n w(0xba), w(0x78), w(0x25), w(0x2e), w(0x1c), w(0xa6), w(0xb4), w(0xc6),\\\r\n w(0xe8), w(0xdd), w(0x74), w(0x1f), w(0x4b), w(0xbd), w(0x8b), w(0x8a),\\\r\n w(0x70), w(0x3e), w(0xb5), w(0x66), w(0x48), w(0x03), w(0xf6), w(0x0e),\\\r\n w(0x61), w(0x35), w(0x57), w(0xb9), w(0x86), w(0xc1), w(0x1d), w(0x9e),\\\r\n w(0xe1), w(0xf8), w(0x98), w(0x11), w(0x69), w(0xd9), w(0x8e), w(0x94),\\\r\n w(0x9b), w(0x1e), w(0x87), w(0xe9), w(0xce), w(0x55), w(0x28), w(0xdf),\\\r\n w(0x8c), w(0xa1), w(0x89), w(0x0d), w(0xbf), w(0xe6), w(0x42), w(0x68),\\\r\n w(0x41), w(0x99), w(0x2d), w(0x0f), w(0xb0), w(0x54), w(0xbb), w(0x16) }\r\n\r\n#define isb_data(w) {\\\r\n w(0x52), w(0x09), w(0x6a), w(0xd5), w(0x30), w(0x36), w(0xa5), w(0x38),\\\r\n w(0xbf), w(0x40), w(0xa3), w(0x9e), w(0x81), w(0xf3), w(0xd7), w(0xfb),\\\r\n w(0x7c), w(0xe3), w(0x39), w(0x82), w(0x9b), w(0x2f), w(0xff), w(0x87),\\\r\n w(0x34), w(0x8e), w(0x43), w(0x44), w(0xc4), w(0xde), w(0xe9), w(0xcb),\\\r\n w(0x54), w(0x7b), w(0x94), w(0x32), w(0xa6), w(0xc2), w(0x23), w(0x3d),\\\r\n w(0xee), w(0x4c), w(0x95), w(0x0b), w(0x42), w(0xfa), w(0xc3), w(0x4e),\\\r\n w(0x08), w(0x2e), w(0xa1), w(0x66), w(0x28), w(0xd9), w(0x24), w(0xb2),\\\r\n w(0x76), w(0x5b), w(0xa2), w(0x49), w(0x6d), w(0x8b), w(0xd1), w(0x25),\\\r\n w(0x72), w(0xf8), w(0xf6), w(0x64), w(0x86), w(0x68), w(0x98), w(0x16),\\\r\n w(0xd4), w(0xa4), w(0x5c), w(0xcc), w(0x5d), w(0x65), w(0xb6), w(0x92),\\\r\n w(0x6c), w(0x70), w(0x48), w(0x50), w(0xfd), w(0xed), w(0xb9), w(0xda),\\\r\n w(0x5e), w(0x15), w(0x46), w(0x57), w(0xa7), w(0x8d), w(0x9d), w(0x84),\\\r\n w(0x90), w(0xd8), w(0xab), w(0x00), w(0x8c), w(0xbc), w(0xd3), w(0x0a),\\\r\n w(0xf7), w(0xe4), w(0x58), w(0x05), w(0xb8), w(0xb3), w(0x45), w(0x06),\\\r\n w(0xd0), w(0x2c), w(0x1e), w(0x8f), w(0xca), w(0x3f), w(0x0f), w(0x02),\\\r\n w(0xc1), w(0xaf), w(0xbd), w(0x03), w(0x01), w(0x13), w(0x8a), w(0x6b),\\\r\n w(0x3a), w(0x91), w(0x11), w(0x41), w(0x4f), w(0x67), w(0xdc), w(0xea),\\\r\n w(0x97), w(0xf2), w(0xcf), w(0xce), w(0xf0), w(0xb4), w(0xe6), w(0x73),\\\r\n w(0x96), w(0xac), w(0x74), w(0x22), w(0xe7), w(0xad), w(0x35), w(0x85),\\\r\n w(0xe2), w(0xf9), w(0x37), w(0xe8), w(0x1c), w(0x75), w(0xdf), w(0x6e),\\\r\n w(0x47), w(0xf1), w(0x1a), w(0x71), w(0x1d), w(0x29), w(0xc5), w(0x89),\\\r\n w(0x6f), w(0xb7), w(0x62), w(0x0e), w(0xaa), w(0x18), w(0xbe), w(0x1b),\\\r\n w(0xfc), w(0x56), w(0x3e), w(0x4b), w(0xc6), w(0xd2), w(0x79), w(0x20),\\\r\n w(0x9a), w(0xdb), w(0xc0), w(0xfe), w(0x78), w(0xcd), w(0x5a), w(0xf4),\\\r\n w(0x1f), w(0xdd), w(0xa8), w(0x33), w(0x88), w(0x07), w(0xc7), w(0x31),\\\r\n w(0xb1), w(0x12), w(0x10), w(0x59), w(0x27), w(0x80), w(0xec), w(0x5f),\\\r\n w(0x60), w(0x51), w(0x7f), w(0xa9), w(0x19), w(0xb5), w(0x4a), w(0x0d),\\\r\n w(0x2d), w(0xe5), w(0x7a), w(0x9f), w(0x93), w(0xc9), w(0x9c), w(0xef),\\\r\n w(0xa0), w(0xe0), w(0x3b), w(0x4d), w(0xae), w(0x2a), w(0xf5), w(0xb0),\\\r\n w(0xc8), w(0xeb), w(0xbb), w(0x3c), w(0x83), w(0x53), w(0x99), w(0x61),\\\r\n w(0x17), w(0x2b), w(0x04), w(0x7e), w(0xba), w(0x77), w(0xd6), w(0x26),\\\r\n w(0xe1), w(0x69), w(0x14), w(0x63), w(0x55), w(0x21), w(0x0c), w(0x7d) }\r\n\r\n#define mm_data(w) {\\\r\n w(0x00), w(0x01), w(0x02), w(0x03), w(0x04), w(0x05), w(0x06), w(0x07),\\\r\n w(0x08), w(0x09), w(0x0a), w(0x0b), w(0x0c), w(0x0d), w(0x0e), w(0x0f),\\\r\n w(0x10), w(0x11), w(0x12), w(0x13), w(0x14), w(0x15), w(0x16), w(0x17),\\\r\n w(0x18), w(0x19), w(0x1a), w(0x1b), w(0x1c), w(0x1d), w(0x1e), w(0x1f),\\\r\n w(0x20), w(0x21), w(0x22), w(0x23), w(0x24), w(0x25), w(0x26), w(0x27),\\\r\n w(0x28), w(0x29), w(0x2a), w(0x2b), w(0x2c), w(0x2d), w(0x2e), w(0x2f),\\\r\n w(0x30), w(0x31), w(0x32), w(0x33), w(0x34), w(0x35), w(0x36), w(0x37),\\\r\n w(0x38), w(0x39), w(0x3a), w(0x3b), w(0x3c), w(0x3d), w(0x3e), w(0x3f),\\\r\n w(0x40), w(0x41), w(0x42), w(0x43), w(0x44), w(0x45), w(0x46), w(0x47),\\\r\n w(0x48), w(0x49), w(0x4a), w(0x4b), w(0x4c), w(0x4d), w(0x4e), w(0x4f),\\\r\n w(0x50), w(0x51), w(0x52), w(0x53), w(0x54), w(0x55), w(0x56), w(0x57),\\\r\n w(0x58), w(0x59), w(0x5a), w(0x5b), w(0x5c), w(0x5d), w(0x5e), w(0x5f),\\\r\n w(0x60), w(0x61), w(0x62), w(0x63), w(0x64), w(0x65), w(0x66), w(0x67),\\\r\n w(0x68), w(0x69), w(0x6a), w(0x6b), w(0x6c), w(0x6d), w(0x6e), w(0x6f),\\\r\n w(0x70), w(0x71), w(0x72), w(0x73), w(0x74), w(0x75), w(0x76), w(0x77),\\\r\n w(0x78), w(0x79), w(0x7a), w(0x7b), w(0x7c), w(0x7d), w(0x7e), w(0x7f),\\\r\n w(0x80), w(0x81), w(0x82), w(0x83), w(0x84), w(0x85), w(0x86), w(0x87),\\\r\n w(0x88), w(0x89), w(0x8a), w(0x8b), w(0x8c), w(0x8d), w(0x8e), w(0x8f),\\\r\n w(0x90), w(0x91), w(0x92), w(0x93), w(0x94), w(0x95), w(0x96), w(0x97),\\\r\n w(0x98), w(0x99), w(0x9a), w(0x9b), w(0x9c), w(0x9d), w(0x9e), w(0x9f),\\\r\n w(0xa0), w(0xa1), w(0xa2), w(0xa3), w(0xa4), w(0xa5), w(0xa6), w(0xa7),\\\r\n w(0xa8), w(0xa9), w(0xaa), w(0xab), w(0xac), w(0xad), w(0xae), w(0xaf),\\\r\n w(0xb0), w(0xb1), w(0xb2), w(0xb3), w(0xb4), w(0xb5), w(0xb6), w(0xb7),\\\r\n w(0xb8), w(0xb9), w(0xba), w(0xbb), w(0xbc), w(0xbd), w(0xbe), w(0xbf),\\\r\n w(0xc0), w(0xc1), w(0xc2), w(0xc3), w(0xc4), w(0xc5), w(0xc6), w(0xc7),\\\r\n w(0xc8), w(0xc9), w(0xca), w(0xcb), w(0xcc), w(0xcd), w(0xce), w(0xcf),\\\r\n w(0xd0), w(0xd1), w(0xd2), w(0xd3), w(0xd4), w(0xd5), w(0xd6), w(0xd7),\\\r\n w(0xd8), w(0xd9), w(0xda), w(0xdb), w(0xdc), w(0xdd), w(0xde), w(0xdf),\\\r\n w(0xe0), w(0xe1), w(0xe2), w(0xe3), w(0xe4), w(0xe5), w(0xe6), w(0xe7),\\\r\n w(0xe8), w(0xe9), w(0xea), w(0xeb), w(0xec), w(0xed), w(0xee), w(0xef),\\\r\n w(0xf0), w(0xf1), w(0xf2), w(0xf3), w(0xf4), w(0xf5), w(0xf6), w(0xf7),\\\r\n w(0xf8), w(0xf9), w(0xfa), w(0xfb), w(0xfc), w(0xfd), w(0xfe), w(0xff) }\r\n\r\n#define rc_data(w) {\\\r\n w(0x01), w(0x02), w(0x04), w(0x08), w(0x10),w(0x20), w(0x40), w(0x80),\\\r\n w(0x1b), w(0x36) }\r\n\r\n#define h0(x) (x)\r\n\r\n#define w0(p) bytes2word(p, 0, 0, 0)\r\n#define w1(p) bytes2word(0, p, 0, 0)\r\n#define w2(p) bytes2word(0, 0, p, 0)\r\n#define w3(p) bytes2word(0, 0, 0, p)\r\n\r\n#define u0(p) bytes2word(f2(p), p, p, f3(p))\r\n#define u1(p) bytes2word(f3(p), f2(p), p, p)\r\n#define u2(p) bytes2word(p, f3(p), f2(p), p)\r\n#define u3(p) bytes2word(p, p, f3(p), f2(p))\r\n\r\n#define v0(p) bytes2word(fe(p), f9(p), fd(p), fb(p))\r\n#define v1(p) bytes2word(fb(p), fe(p), f9(p), fd(p))\r\n#define v2(p) bytes2word(fd(p), fb(p), fe(p), f9(p))\r\n#define v3(p) bytes2word(f9(p), fd(p), fb(p), fe(p))\r\n\r\n#endif\r\n\r\n#if defined(FIXED_TABLES) || !defined(FF_TABLES)\r\n\r\n#define f2(x) ((x<<1) ^ (((x>>7) & 1) * WPOLY))\r\n#define f4(x) ((x<<2) ^ (((x>>6) & 1) * WPOLY) ^ (((x>>6) & 2) * WPOLY))\r\n#define f8(x) ((x<<3) ^ (((x>>5) & 1) * WPOLY) ^ (((x>>5) & 2) * WPOLY) \\\r\n ^ (((x>>5) & 4) * WPOLY))\r\n#define f3(x) (f2(x) ^ x)\r\n#define f9(x) (f8(x) ^ x)\r\n#define fb(x) (f8(x) ^ f2(x) ^ x)\r\n#define fd(x) (f8(x) ^ f4(x) ^ x)\r\n#define fe(x) (f8(x) ^ f4(x) ^ f2(x))\r\n\r\n#else\r\n\r\n#define f2(x) ((x) ? pow[log[x] + 0x19] : 0)\r\n#define f3(x) ((x) ? pow[log[x] + 0x01] : 0)\r\n#define f9(x) ((x) ? pow[log[x] + 0xc7] : 0)\r\n#define fb(x) ((x) ? pow[log[x] + 0x68] : 0)\r\n#define fd(x) ((x) ? pow[log[x] + 0xee] : 0)\r\n#define fe(x) ((x) ? pow[log[x] + 0xdf] : 0)\r\n\r\n#endif\r\n\r\n#include \"aestab.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#if defined(FIXED_TABLES)\r\n\r\n/* implemented in case of wrong call for fixed tables */\r\n\r\nAES_RETURN aes_init(void)\r\n{\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#else /* Generate the tables for the dynamic table option */\r\n\r\n#if defined(FF_TABLES)\r\n\r\n#define gf_inv(x) ((x) ? pow[ 255 - log[x]] : 0)\r\n\r\n#else \r\n\r\n/* It will generally be sensible to use tables to compute finite\r\n field multiplies and inverses but where memory is scarse this\r\n code might sometimes be better. But it only has effect during\r\n initialisation so its pretty unimportant in overall terms.\r\n*/\r\n\r\n/* return 2 ^ (n - 1) where n is the bit number of the highest bit\r\n set in x with x in the range 1 < x < 0x00000200. This form is\r\n used so that locals within fi can be bytes rather than words\r\n*/\r\n\r\nstatic uint_8t hibit(const uint_32t x)\r\n{ uint_8t r = (uint_8t)((x >> 1) | (x >> 2));\r\n\r\n r |= (r >> 2);\r\n r |= (r >> 4);\r\n return (r + 1) >> 1;\r\n}\r\n\r\n/* return the inverse of the finite field element x */\r\n\r\nstatic uint_8t gf_inv(const uint_8t x)\r\n{ uint_8t p1 = x, p2 = BPOLY, n1 = hibit(x), n2 = 0x80, v1 = 1, v2 = 0;\r\n\r\n if(x < 2) \r\n return x;\r\n\r\n for( ; ; )\r\n {\r\n if(n1)\r\n while(n2 >= n1) /* divide polynomial p2 by p1 */\r\n {\r\n n2 /= n1; /* shift smaller polynomial left */ \r\n p2 ^= (p1 * n2) & 0xff; /* and remove from larger one */\r\n v2 ^= v1 * n2; /* shift accumulated value and */ \r\n n2 = hibit(p2); /* add into result */\r\n }\r\n else\r\n return v1;\r\n\r\n if(n2) /* repeat with values swapped */ \r\n while(n1 >= n2)\r\n {\r\n n1 /= n2; \r\n p1 ^= p2 * n1; \r\n v1 ^= v2 * n1; \r\n n1 = hibit(p1);\r\n }\r\n else\r\n return v2;\r\n }\r\n}\r\n\r\n#endif\r\n\r\n/* The forward and inverse affine transformations used in the S-box */\r\nuint_8t fwd_affine(const uint_8t x)\r\n{ uint_32t w = x;\r\n w ^= (w << 1) ^ (w << 2) ^ (w << 3) ^ (w << 4);\r\n return 0x63 ^ ((w ^ (w >> 8)) & 0xff);\r\n}\r\n\r\nuint_8t inv_affine(const uint_8t x)\r\n{ uint_32t w = x;\r\n w = (w << 1) ^ (w << 3) ^ (w << 6);\r\n return 0x05 ^ ((w ^ (w >> 8)) & 0xff);\r\n}\r\n\r\nstatic int init = 0;\r\n\r\nAES_RETURN aes_init(void)\r\n{ uint_32t i, w;\r\n\r\n#if defined(FF_TABLES)\r\n\r\n uint_8t pow[512], log[256];\r\n\r\n if(init)\r\n return EXIT_SUCCESS;\r\n /* log and power tables for GF(2^8) finite field with\r\n WPOLY as modular polynomial - the simplest primitive\r\n root is 0x03, used here to generate the tables\r\n */\r\n\r\n i = 0; w = 1;\r\n do\r\n {\r\n pow[i] = (uint_8t)w;\r\n pow[i + 255] = (uint_8t)w;\r\n log[w] = (uint_8t)i++;\r\n w ^= (w << 1) ^ (w & 0x80 ? WPOLY : 0);\r\n }\r\n while (w != 1);\r\n\r\n#else\r\n if(init)\r\n return EXIT_SUCCESS;\r\n#endif\r\n\r\n for(i = 0, w = 1; i < RC_LENGTH; ++i)\r\n {\r\n t_set(r,c)[i] = bytes2word(w, 0, 0, 0);\r\n w = f2(w);\r\n }\r\n\r\n for(i = 0; i < 256; ++i)\r\n { uint_8t b;\r\n\r\n b = fwd_affine(gf_inv((uint_8t)i));\r\n w = bytes2word(f2(b), b, b, f3(b));\r\n\r\n#if defined( SBX_SET )\r\n t_set(s,box)[i] = b;\r\n#endif\r\n\r\n#if defined( FT1_SET ) /* tables for a normal encryption round */\r\n t_set(f,n)[i] = w;\r\n#endif\r\n#if defined( FT4_SET )\r\n t_set(f,n)[0][i] = w;\r\n t_set(f,n)[1][i] = upr(w,1);\r\n t_set(f,n)[2][i] = upr(w,2);\r\n t_set(f,n)[3][i] = upr(w,3);\r\n#endif\r\n w = bytes2word(b, 0, 0, 0);\r\n\r\n#if defined( FL1_SET ) /* tables for last encryption round (may also */\r\n t_set(f,l)[i] = w; /* be used in the key schedule) */\r\n#endif\r\n#if defined( FL4_SET )\r\n t_set(f,l)[0][i] = w;\r\n t_set(f,l)[1][i] = upr(w,1);\r\n t_set(f,l)[2][i] = upr(w,2);\r\n t_set(f,l)[3][i] = upr(w,3);\r\n#endif\r\n\r\n#if defined( LS1_SET )\t\t\t/* table for key schedule if t_set(f,l) above is*/\r\n t_set(l,s)[i] = w; /* not of the required form */\r\n#endif\r\n#if defined( LS4_SET )\r\n t_set(l,s)[0][i] = w;\r\n t_set(l,s)[1][i] = upr(w,1);\r\n t_set(l,s)[2][i] = upr(w,2);\r\n t_set(l,s)[3][i] = upr(w,3);\r\n#endif\r\n\r\n b = gf_inv(inv_affine((uint_8t)i));\r\n w = bytes2word(fe(b), f9(b), fd(b), fb(b));\r\n\r\n#if defined( IM1_SET )\t\t\t/* tables for the inverse mix column operation */\r\n t_set(i,m)[b] = w;\r\n#endif\r\n#if defined( IM4_SET )\r\n t_set(i,m)[0][b] = w;\r\n t_set(i,m)[1][b] = upr(w,1);\r\n t_set(i,m)[2][b] = upr(w,2);\r\n t_set(i,m)[3][b] = upr(w,3);\r\n#endif\r\n\r\n#if defined( ISB_SET )\r\n t_set(i,box)[i] = b;\r\n#endif\r\n#if defined( IT1_SET )\t\t\t/* tables for a normal decryption round */\r\n t_set(i,n)[i] = w;\r\n#endif\r\n#if defined( IT4_SET )\r\n t_set(i,n)[0][i] = w;\r\n t_set(i,n)[1][i] = upr(w,1);\r\n t_set(i,n)[2][i] = upr(w,2);\r\n t_set(i,n)[3][i] = upr(w,3);\r\n#endif\r\n w = bytes2word(b, 0, 0, 0);\r\n#if defined( IL1_SET )\t\t\t/* tables for last decryption round */\r\n t_set(i,l)[i] = w;\r\n#endif\r\n#if defined( IL4_SET )\r\n t_set(i,l)[0][i] = w;\r\n t_set(i,l)[1][i] = upr(w,1);\r\n t_set(i,l)[2][i] = upr(w,2);\r\n t_set(i,l)[3][i] = upr(w,3);\r\n#endif\r\n }\r\n init = 1;\r\n return EXIT_SUCCESS;\r\n}\r\n\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n"
},
{
"path": "libs/minizip/source/aes/aestab.h",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n\r\n This file contains the code for declaring the tables needed to implement\r\n AES. The file aesopt.h is assumed to be included before this header file.\r\n If there are no global variables, the definitions here can be used to put\r\n the AES tables in a structure so that a pointer can then be added to the\r\n AES context to pass them to the AES routines that need them. If this\r\n facility is used, the calling program has to ensure that this pointer is\r\n managed appropriately. In particular, the value of the t_dec(in,it) item\r\n in the table structure must be set to zero in order to ensure that the\r\n tables are initialised. In practice the three code sequences in aeskey.c\r\n that control the calls to aes_init() and the aes_init() routine itself will\r\n have to be changed for a specific implementation. If global variables are\r\n available it will generally be preferable to use them with the precomputed\r\n FIXED_TABLES option that uses static global tables.\r\n\r\n The following defines can be used to control the way the tables\r\n are defined, initialised and used in embedded environments that\r\n require special features for these purposes\r\n\r\n the 't_dec' construction is used to declare fixed table arrays\r\n the 't_set' construction is used to set fixed table values\r\n the 't_use' construction is used to access fixed table values\r\n\r\n 256 byte tables:\r\n\r\n t_xxx(s,box) => forward S box\r\n t_xxx(i,box) => inverse S box\r\n\r\n 256 32-bit word OR 4 x 256 32-bit word tables:\r\n\r\n t_xxx(f,n) => forward normal round\r\n t_xxx(f,l) => forward last round\r\n t_xxx(i,n) => inverse normal round\r\n t_xxx(i,l) => inverse last round\r\n t_xxx(l,s) => key schedule table\r\n t_xxx(i,m) => key schedule table\r\n\r\n Other variables and tables:\r\n\r\n t_xxx(r,c) => the rcon table\r\n*/\r\n\r\n#if !defined( _AESTAB_H )\r\n#define _AESTAB_H\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\" {\r\n#endif\r\n\r\n#define t_dec(m,n) t_##m##n\r\n#define t_set(m,n) t_##m##n\r\n#define t_use(m,n) t_##m##n\r\n\r\n#if defined(FIXED_TABLES)\r\n# if !defined( __GNUC__ ) && (defined( __MSDOS__ ) || defined( __WIN16__ ))\r\n/* make tables far data to avoid using too much DGROUP space (PG) */\r\n# define CONST const far\r\n# else\r\n# define CONST const\r\n# endif\r\n#else\r\n# define CONST\r\n#endif\r\n\r\n#if defined(DO_TABLES)\r\n# define EXTERN\r\n#else\r\n# define EXTERN extern\r\n#endif\r\n\r\n#if defined(_MSC_VER) && defined(TABLE_ALIGN)\r\n#define ALIGN __declspec(align(TABLE_ALIGN))\r\n#else\r\n#define ALIGN\r\n#endif\r\n\r\n#if defined( __WATCOMC__ ) && ( __WATCOMC__ >= 1100 )\r\n# define XP_DIR __cdecl\r\n#else\r\n# define XP_DIR\r\n#endif\r\n\r\n#if defined(DO_TABLES) && defined(FIXED_TABLES)\r\n#define d_1(t,n,b,e) EXTERN ALIGN CONST XP_DIR t n[256] = b(e)\r\n#define d_4(t,n,b,e,f,g,h) EXTERN ALIGN CONST XP_DIR t n[4][256] = { b(e), b(f), b(g), b(h) }\r\nEXTERN ALIGN CONST uint_32t t_dec(r,c)[RC_LENGTH] = rc_data(w0);\r\n#else\r\n#define d_1(t,n,b,e) EXTERN ALIGN CONST XP_DIR t n[256]\r\n#define d_4(t,n,b,e,f,g,h) EXTERN ALIGN CONST XP_DIR t n[4][256]\r\nEXTERN ALIGN CONST uint_32t t_dec(r,c)[RC_LENGTH];\r\n#endif\r\n\r\n#if defined( SBX_SET )\r\n d_1(uint_8t, t_dec(s,box), sb_data, h0);\r\n#endif\r\n#if defined( ISB_SET )\r\n d_1(uint_8t, t_dec(i,box), isb_data, h0);\r\n#endif\r\n\r\n#if defined( FT1_SET )\r\n d_1(uint_32t, t_dec(f,n), sb_data, u0);\r\n#endif\r\n#if defined( FT4_SET )\r\n d_4(uint_32t, t_dec(f,n), sb_data, u0, u1, u2, u3);\r\n#endif\r\n\r\n#if defined( FL1_SET )\r\n d_1(uint_32t, t_dec(f,l), sb_data, w0);\r\n#endif\r\n#if defined( FL4_SET )\r\n d_4(uint_32t, t_dec(f,l), sb_data, w0, w1, w2, w3);\r\n#endif\r\n\r\n#if defined( IT1_SET )\r\n d_1(uint_32t, t_dec(i,n), isb_data, v0);\r\n#endif\r\n#if defined( IT4_SET )\r\n d_4(uint_32t, t_dec(i,n), isb_data, v0, v1, v2, v3);\r\n#endif\r\n\r\n#if defined( IL1_SET )\r\n d_1(uint_32t, t_dec(i,l), isb_data, w0);\r\n#endif\r\n#if defined( IL4_SET )\r\n d_4(uint_32t, t_dec(i,l), isb_data, w0, w1, w2, w3);\r\n#endif\r\n\r\n#if defined( LS1_SET )\r\n#if defined( FL1_SET )\r\n#undef LS1_SET\r\n#else\r\n d_1(uint_32t, t_dec(l,s), sb_data, w0);\r\n#endif\r\n#endif\r\n\r\n#if defined( LS4_SET )\r\n#if defined( FL4_SET )\r\n#undef LS4_SET\r\n#else\r\n d_4(uint_32t, t_dec(l,s), sb_data, w0, w1, w2, w3);\r\n#endif\r\n#endif\r\n\r\n#if defined( IM1_SET )\r\n d_1(uint_32t, t_dec(i,m), mm_data, v0);\r\n#endif\r\n#if defined( IM4_SET )\r\n d_4(uint_32t, t_dec(i,m), mm_data, v0, v1, v2, v3);\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/brg_endian.h",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n*/\r\n\r\n#ifndef _BRG_ENDIAN_H\r\n#define _BRG_ENDIAN_H\r\n\r\n#define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */\r\n#define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */\r\n\r\n/* Include files where endian defines and byteswap functions may reside */\r\n#if defined( __sun )\r\n# include <sys/isa_defs.h>\r\n#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )\r\n# include <sys/endian.h>\r\n#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \\\r\n defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )\r\n# include <machine/endian.h>\r\n#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )\r\n# if !defined( __MINGW32__ ) && !defined( _AIX )\r\n# include <endian.h>\r\n# if !defined( __BEOS__ )\r\n# include <byteswap.h>\r\n# endif\r\n# endif\r\n#endif\r\n\r\n/* Now attempt to set the define for platform byte order using any */\r\n/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */\r\n/* seem to encompass most endian symbol definitions */\r\n\r\n#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )\r\n# if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n# elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n# endif\r\n#elif defined( BIG_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n#elif defined( LITTLE_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#endif\r\n\r\n#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )\r\n# if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n# elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n# endif\r\n#elif defined( _BIG_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n#elif defined( _LITTLE_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#endif\r\n\r\n#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )\r\n# if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n# elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n# endif\r\n#elif defined( __BIG_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n#elif defined( __LITTLE_ENDIAN )\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#endif\r\n\r\n#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )\r\n# if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n# elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n# endif\r\n#elif defined( __BIG_ENDIAN__ )\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n#elif defined( __LITTLE_ENDIAN__ )\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#endif\r\n\r\n/* if the platform byte order could not be determined, then try to */\r\n/* set this define using common machine defines */\r\n#if !defined(PLATFORM_BYTE_ORDER)\r\n\r\n#if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \\\r\n defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \\\r\n defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \\\r\n defined( vax ) || defined( vms ) || defined( VMS ) || \\\r\n defined( __VMS ) || defined( _M_X64 )\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n\r\n#elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \\\r\n defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \\\r\n defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \\\r\n defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \\\r\n defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \\\r\n defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \\\r\n defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX )\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n\r\n#elif 0 /* **** EDIT HERE IF NECESSARY **** */\r\n# define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN\r\n#elif 0 /* **** EDIT HERE IF NECESSARY **** */\r\n# define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN\r\n#else\r\n# error Please edit lines 126 or 128 in brg_endian.h to set the platform byte order\r\n#endif\r\n\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/brg_types.h",
"content": "/*\r\n---------------------------------------------------------------------------\r\nCopyright (c) 1998-2010, Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\nThe redistribution and use of this software (with or without changes)\r\nis allowed without the payment of fees or royalties provided that:\r\n\r\n source code distributions include the above copyright notice, this\r\n list of conditions and the following disclaimer;\r\n\r\n binary distributions include the above copyright notice, this list\r\n of conditions and the following disclaimer in their documentation.\r\n\r\nThis software is provided 'as is' with no explicit or implied warranties\r\nin respect of its operation, including, but not limited to, correctness\r\nand fitness for purpose.\r\n---------------------------------------------------------------------------\r\nIssue Date: 20/12/2007\r\n\r\n The unsigned integer types defined here are of the form uint_<nn>t where\r\n <nn> is the length of the type; for example, the unsigned 32-bit type is\r\n 'uint_32t'. These are NOT the same as the 'C99 integer types' that are\r\n defined in the inttypes.h and stdint.h headers since attempts to use these\r\n types have shown that support for them is still highly variable. However,\r\n since the latter are of the form uint<nn>_t, a regular expression search\r\n and replace (in VC++ search on 'uint_{:z}t' and replace with 'uint\\1_t')\r\n can be used to convert the types used here to the C99 standard types.\r\n*/\r\n\r\n#ifndef _BRG_TYPES_H\r\n#define _BRG_TYPES_H\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\" {\r\n#endif\r\n\r\n#include <limits.h>\r\n\r\n#if defined( _MSC_VER ) && ( _MSC_VER >= 1300 )\r\n# include <stddef.h>\r\n# define ptrint_t intptr_t\r\n#elif defined( __ECOS__ )\r\n# define intptr_t unsigned int\r\n# define ptrint_t intptr_t\r\n#elif defined( __GNUC__ ) && ( __GNUC__ >= 3 )\r\n# include <stdint.h>\r\n# define ptrint_t intptr_t\r\n#else\r\n# define ptrint_t int\r\n#endif\r\n\r\n#ifndef BRG_UI8\r\n# define BRG_UI8\r\n# if UCHAR_MAX == 255u\r\n typedef unsigned char uint_8t;\r\n# else\r\n# error Please define uint_8t as an 8-bit unsigned integer type in brg_types.h\r\n# endif\r\n#endif\r\n\r\n#ifndef BRG_UI16\r\n# define BRG_UI16\r\n# if USHRT_MAX == 65535u\r\n typedef unsigned short uint_16t;\r\n# else\r\n# error Please define uint_16t as a 16-bit unsigned short type in brg_types.h\r\n# endif\r\n#endif\r\n\r\n#ifndef BRG_UI32\r\n# define BRG_UI32\r\n# if UINT_MAX == 4294967295u\r\n# define li_32(h) 0x##h##u\r\n typedef unsigned int uint_32t;\r\n# elif ULONG_MAX == 4294967295u\r\n# define li_32(h) 0x##h##ul\r\n typedef unsigned long uint_32t;\r\n# elif defined( _CRAY )\r\n# error This code needs 32-bit data types, which Cray machines do not provide\r\n# else\r\n# error Please define uint_32t as a 32-bit unsigned integer type in brg_types.h\r\n# endif\r\n#endif\r\n\r\n#ifndef BRG_UI64\r\n# if defined( __BORLANDC__ ) && !defined( __MSDOS__ )\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ui64\r\n typedef unsigned __int64 uint_64t;\r\n# elif defined( _MSC_VER ) && ( _MSC_VER < 1300 ) /* 1300 == VC++ 7.0 */\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ui64\r\n typedef unsigned __int64 uint_64t;\r\n# elif defined( __sun ) && defined( ULONG_MAX ) && ULONG_MAX == 0xfffffffful\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ull\r\n typedef unsigned long long uint_64t;\r\n# elif defined( __MVS__ )\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ull\r\n typedef unsigned int long long uint_64t;\r\n# elif defined( UINT_MAX ) && UINT_MAX > 4294967295u\r\n# if UINT_MAX == 18446744073709551615u\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##u\r\n typedef unsigned int uint_64t;\r\n# endif\r\n# elif defined( ULONG_MAX ) && ULONG_MAX > 4294967295u\r\n# if ULONG_MAX == 18446744073709551615ul\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ul\r\n typedef unsigned long uint_64t;\r\n# endif\r\n# elif defined( ULLONG_MAX ) && ULLONG_MAX > 4294967295u\r\n# if ULLONG_MAX == 18446744073709551615ull\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ull\r\n typedef unsigned long long uint_64t;\r\n# endif\r\n# elif defined( ULONG_LONG_MAX ) && ULONG_LONG_MAX > 4294967295u\r\n# if ULONG_LONG_MAX == 18446744073709551615ull\r\n# define BRG_UI64\r\n# define li_64(h) 0x##h##ull\r\n typedef unsigned long long uint_64t;\r\n# endif\r\n# endif\r\n#endif\r\n\r\n#if !defined( BRG_UI64 )\r\n# if defined( NEED_UINT_64T )\r\n# error Please define uint_64t as an unsigned 64 bit type in brg_types.h\r\n# endif\r\n#endif\r\n\r\n#ifndef RETURN_VALUES\r\n# define RETURN_VALUES\r\n# if defined( DLL_EXPORT )\r\n# if defined( _MSC_VER ) || defined ( __INTEL_COMPILER )\r\n# define VOID_RETURN __declspec( dllexport ) void __stdcall\r\n# define INT_RETURN __declspec( dllexport ) int __stdcall\r\n# elif defined( __GNUC__ )\r\n# define VOID_RETURN __declspec( __dllexport__ ) void\r\n# define INT_RETURN __declspec( __dllexport__ ) int\r\n# else\r\n# error Use of the DLL is only available on the Microsoft, Intel and GCC compilers\r\n# endif\r\n# elif defined( DLL_IMPORT )\r\n# if defined( _MSC_VER ) || defined ( __INTEL_COMPILER )\r\n# define VOID_RETURN __declspec( dllimport ) void __stdcall\r\n# define INT_RETURN __declspec( dllimport ) int __stdcall\r\n# elif defined( __GNUC__ )\r\n# define VOID_RETURN __declspec( __dllimport__ ) void\r\n# define INT_RETURN __declspec( __dllimport__ ) int\r\n# else\r\n# error Use of the DLL is only available on the Microsoft, Intel and GCC compilers\r\n# endif\r\n# elif defined( __WATCOMC__ )\r\n# define VOID_RETURN void __cdecl\r\n# define INT_RETURN int __cdecl\r\n# else\r\n# define VOID_RETURN void\r\n# define INT_RETURN int\r\n# endif\r\n#endif\r\n\r\n/*\tThese defines are used to detect and set the memory alignment of pointers.\r\n Note that offsets are in bytes.\r\n\r\n ALIGN_OFFSET(x,n)\t\t\treturn the positive or zero offset of \r\n the memory addressed by the pointer 'x' \r\n from an address that is aligned on an \r\n 'n' byte boundary ('n' is a power of 2)\r\n\r\n ALIGN_FLOOR(x,n)\t\t\treturn a pointer that points to memory\r\n that is aligned on an 'n' byte boundary \r\n and is not higher than the memory address\r\n pointed to by 'x' ('n' is a power of 2)\r\n\r\n ALIGN_CEIL(x,n)\t\t\t\treturn a pointer that points to memory\r\n that is aligned on an 'n' byte boundary \r\n and is not lower than the memory address\r\n pointed to by 'x' ('n' is a power of 2)\r\n*/\r\n\r\n#define ALIGN_OFFSET(x,n)\t(((ptrint_t)(x)) & ((n) - 1))\r\n#define ALIGN_FLOOR(x,n)\t((uint_8t*)(x) - ( ((ptrint_t)(x)) & ((n) - 1)))\r\n#define ALIGN_CEIL(x,n)\t\t((uint_8t*)(x) + (-((ptrint_t)(x)) & ((n) - 1)))\r\n\r\n/* These defines are used to declare buffers in a way that allows\r\n faster operations on longer variables to be used. In all these\r\n defines 'size' must be a power of 2 and >= 8. NOTE that the \r\n buffer size is in bytes but the type length is in bits\r\n\r\n UNIT_TYPEDEF(x,size) declares a variable 'x' of length \r\n 'size' bits\r\n\r\n BUFR_TYPEDEF(x,size,bsize) declares a buffer 'x' of length 'bsize' \r\n bytes defined as an array of variables\r\n each of 'size' bits (bsize must be a \r\n multiple of size / 8)\r\n\r\n UNIT_CAST(x,size) casts a variable to a type of \r\n length 'size' bits\r\n\r\n UPTR_CAST(x,size) casts a pointer to a pointer to a \r\n varaiable of length 'size' bits\r\n*/\r\n\r\n#define UI_TYPE(size) uint_##size##t\r\n#define UNIT_TYPEDEF(x,size) typedef UI_TYPE(size) x\r\n#define BUFR_TYPEDEF(x,size,bsize) typedef UI_TYPE(size) x[bsize / (size >> 3)]\r\n#define UNIT_CAST(x,size) ((UI_TYPE(size) )(x)) \r\n#define UPTR_CAST(x,size) ((UI_TYPE(size)*)(x))\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/entropy.c",
"content": "#ifdef _WIN32\r\n#include <windows.h>\r\n#else\r\n#include <sys/stat.h>\r\n#include <fcntl.h>\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#ifdef _WIN32\r\nint entropy_fun(unsigned char buf[], unsigned int len)\r\n{\r\n HCRYPTPROV provider;\r\n unsigned __int64 pentium_tsc[1];\r\n unsigned int i;\r\n int result = 0;\r\n\r\n\r\n if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))\r\n {\r\n result = CryptGenRandom(provider, len, buf);\r\n CryptReleaseContext(provider, 0);\r\n if (result)\r\n return len;\r\n }\r\n\r\n QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc);\r\n\r\n for(i = 0; i < 8 && i < len; ++i)\r\n buf[i] = ((unsigned char*)pentium_tsc)[i];\r\n\r\n return i;\r\n}\r\n#else\r\nint entropy_fun(unsigned char buf[], unsigned int len)\r\n{\r\n int frand = open(\"/dev/random\", O_RDONLY);\r\n int rlen = 0;\r\n if (frand != -1)\r\n {\r\n rlen = read(frand, buf, len);\r\n close(frand);\r\n }\r\n return rlen;\r\n}\r\n#endif\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/entropy.h",
"content": "\r\n#ifndef _ENTROPY_FUN_H\r\n#define _ENTROPY_FUN_H\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\nint entropy_fun(unsigned char buf[], unsigned int len);\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/fileenc.c",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK.\r\n All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n -------------------------------------------------------------------------\r\n Issue Date: 24/01/2003\r\n\r\n This file implements password based file encryption and authentication \r\n using AES in CTR mode, HMAC-SHA1 authentication and RFC2898 password \r\n based key derivation.\r\n\r\n*/\r\n\r\n#include <memory.h>\r\n\r\n#include \"fileenc.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* subroutine for data encryption/decryption */\r\n/* this could be speeded up a lot by aligning */\r\n/* buffers and using 32 bit operations */\r\n\r\nstatic void encr_data(unsigned char data[], unsigned long d_len, fcrypt_ctx cx[1])\r\n{ unsigned long i = 0, pos = cx->encr_pos;\r\n\r\n while(i < d_len)\r\n {\r\n if(pos == AES_BLOCK_SIZE)\r\n { unsigned int j = 0;\r\n /* increment encryption nonce */\r\n while(j < 8 && !++cx->nonce[j])\r\n ++j;\r\n /* encrypt the nonce to form next xor buffer */\r\n aes_encrypt(cx->nonce, cx->encr_bfr, cx->encr_ctx);\r\n pos = 0;\r\n }\r\n\r\n data[i++] ^= cx->encr_bfr[pos++];\r\n }\r\n\r\n cx->encr_pos = pos;\r\n}\r\n\r\nint fcrypt_init(\r\n int mode, /* the mode to be used (input) */\r\n const unsigned char pwd[], /* the user specified password (input) */\r\n unsigned int pwd_len, /* the length of the password (input) */\r\n const unsigned char salt[], /* the salt (input) */\r\n#ifdef PASSWORD_VERIFIER\r\n unsigned char pwd_ver[PWD_VER_LENGTH], /* 2 byte password verifier (output) */\r\n#endif\r\n fcrypt_ctx cx[1]) /* the file encryption context (output) */\r\n{ unsigned char kbuf[2 * MAX_KEY_LENGTH + PWD_VER_LENGTH];\r\n\r\n if(pwd_len > MAX_PWD_LENGTH)\r\n return PASSWORD_TOO_LONG;\r\n\r\n if(mode < 1 || mode > 3)\r\n return BAD_MODE;\r\n\r\n cx->mode = mode;\r\n cx->pwd_len = pwd_len;\r\n\r\n /* derive the encryption and authentication keys and the password verifier */\r\n derive_key(pwd, pwd_len, salt, SALT_LENGTH(mode), KEYING_ITERATIONS,\r\n kbuf, 2 * KEY_LENGTH(mode) + PWD_VER_LENGTH);\r\n\r\n /* initialise the encryption nonce and buffer pos */\r\n cx->encr_pos = AES_BLOCK_SIZE;\r\n /* if we need a random component in the encryption */\r\n /* nonce, this is where it would have to be set */\r\n memset(cx->nonce, 0, AES_BLOCK_SIZE * sizeof(unsigned char));\r\n\r\n /* initialise for encryption using key 1 */\r\n aes_encrypt_key(kbuf, KEY_LENGTH(mode), cx->encr_ctx);\r\n\r\n /* initialise for authentication using key 2 */\r\n hmac_sha_begin(cx->auth_ctx);\r\n hmac_sha_key(kbuf + KEY_LENGTH(mode), KEY_LENGTH(mode), cx->auth_ctx);\r\n\r\n#ifdef PASSWORD_VERIFIER\r\n memcpy(pwd_ver, kbuf + 2 * KEY_LENGTH(mode), PWD_VER_LENGTH);\r\n#endif\r\n\r\n return GOOD_RETURN;\r\n}\r\n\r\n/* perform 'in place' encryption and authentication */\r\n\r\nvoid fcrypt_encrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1])\r\n{\r\n encr_data(data, data_len, cx);\r\n hmac_sha_data(data, data_len, cx->auth_ctx);\r\n}\r\n\r\n/* perform 'in place' authentication and decryption */\r\n\r\nvoid fcrypt_decrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1])\r\n{\r\n hmac_sha_data(data, data_len, cx->auth_ctx);\r\n encr_data(data, data_len, cx);\r\n}\r\n\r\n/* close encryption/decryption and return the MAC value */\r\n\r\nint fcrypt_end(unsigned char mac[], fcrypt_ctx cx[1])\r\n{\r\n hmac_sha_end(mac, MAC_LENGTH(cx->mode), cx->auth_ctx);\r\n return MAC_LENGTH(cx->mode); /* return MAC length in bytes */\r\n}\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/fileenc.h",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK.\r\n All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 24/01/2003\r\n\r\n This file contains the header file for fileenc.c, which implements password\r\n based file encryption and authentication using AES in CTR mode, HMAC-SHA1 \r\n authentication and RFC2898 password based key derivation.\r\n*/\r\n\r\n#ifndef _FENC_H\r\n#define _FENC_H\r\n\r\n#include \"aes.h\"\r\n#include \"hmac.h\"\r\n#include \"pwd2key.h\"\r\n\r\n#define PASSWORD_VERIFIER\r\n\r\n#define MAX_KEY_LENGTH 32\r\n#define MAX_PWD_LENGTH 128\r\n#define MAX_SALT_LENGTH 16\r\n#define KEYING_ITERATIONS 1000\r\n\r\n#ifdef PASSWORD_VERIFIER\r\n#define PWD_VER_LENGTH 2\r\n#else\r\n#define PWD_VER_LENGTH 0\r\n#endif\r\n\r\n#define GOOD_RETURN 0\r\n#define PASSWORD_TOO_LONG -100\r\n#define BAD_MODE -101\r\n\r\n/*\r\n Field lengths (in bytes) versus File Encryption Mode (0 < mode < 4)\r\n\r\n Mode Key Salt MAC Overhead\r\n 1 16 8 10 18\r\n 2 24 12 10 22\r\n 3 32 16 10 26\r\n\r\n The following macros assume that the mode value is correct.\r\n*/\r\n\r\n#define KEY_LENGTH(mode) (8 * (mode & 3) + 8)\r\n#define SALT_LENGTH(mode) (4 * (mode & 3) + 4)\r\n#define MAC_LENGTH(mode) (10)\r\n\r\n/* the context for file encryption */\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\ntypedef struct\r\n{ unsigned char nonce[AES_BLOCK_SIZE]; /* the CTR nonce */\r\n unsigned char encr_bfr[AES_BLOCK_SIZE]; /* encrypt buffer */\r\n aes_encrypt_ctx encr_ctx[1]; /* encryption context */\r\n hmac_ctx auth_ctx[1]; /* authentication context */\r\n unsigned int encr_pos; /* block position (enc) */\r\n unsigned int pwd_len; /* password length */\r\n unsigned int mode; /* File encryption mode */\r\n} fcrypt_ctx;\r\n\r\n/* initialise file encryption or decryption */\r\n\r\nint fcrypt_init(\r\n int mode, /* the mode to be used (input) */\r\n const unsigned char pwd[], /* the user specified password (input) */\r\n unsigned int pwd_len, /* the length of the password (input) */\r\n const unsigned char salt[], /* the salt (input) */\r\n#ifdef PASSWORD_VERIFIER\r\n unsigned char pwd_ver[PWD_VER_LENGTH], /* 2 byte password verifier (output) */\r\n#endif\r\n fcrypt_ctx cx[1]); /* the file encryption context (output) */\r\n\r\n/* perform 'in place' encryption or decryption and authentication */\r\n\r\nvoid fcrypt_encrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]);\r\nvoid fcrypt_decrypt(unsigned char data[], unsigned int data_len, fcrypt_ctx cx[1]);\r\n\r\n/* close encryption/decryption and return the MAC value */\r\n/* the return value is the length of the MAC */\r\n\r\nint fcrypt_end(unsigned char mac[], /* the MAC value (output) */\r\n fcrypt_ctx cx[1]); /* the context (input) */\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/hmac.c",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 26/08/2003\r\n\r\n This is an implementation of HMAC, the FIPS standard keyed hash function\r\n*/\r\n\r\n#include \"hmac.h\"\r\n#include \"brg_types.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* initialise the HMAC context to zero */\r\nvoid hmac_sha_begin(hmac_ctx cx[1])\r\n{\r\n memset(cx, 0, sizeof(hmac_ctx));\r\n}\r\n\r\n/* input the HMAC key (can be called multiple times) */\r\nint hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1])\r\n{\r\n if(cx->klen == HMAC_IN_DATA) /* error if further key input */\r\n return HMAC_BAD_MODE; /* is attempted in data mode */\r\n\r\n if(cx->klen + key_len > HASH_INPUT_SIZE) /* if the key has to be hashed */\r\n {\r\n if(cx->klen <= HASH_INPUT_SIZE) /* if the hash has not yet been */\r\n { /* started, initialise it and */\r\n sha_begin(cx->ctx); /* hash stored key characters */\r\n sha_hash(cx->key, cx->klen, cx->ctx);\r\n }\r\n\r\n sha_hash(key, key_len, cx->ctx); /* hash long key data into hash */\r\n }\r\n else /* otherwise store key data */\r\n memcpy(cx->key + cx->klen, key, key_len);\r\n\r\n cx->klen += key_len; /* update the key length count */\r\n return HMAC_OK;\r\n}\r\n\r\n/* input the HMAC data (can be called multiple times) - */\r\n/* note that this call terminates the key input phase */\r\nvoid hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1])\r\n{ unsigned int i;\r\n\r\n if(cx->klen != HMAC_IN_DATA) /* if not yet in data phase */\r\n {\r\n if(cx->klen > HASH_INPUT_SIZE) /* if key is being hashed */\r\n { /* complete the hash and */\r\n sha_end(cx->key, cx->ctx); /* store the result as the */\r\n cx->klen = HASH_OUTPUT_SIZE; /* key and set new length */\r\n }\r\n\r\n /* pad the key if necessary */\r\n memset(cx->key + cx->klen, 0, HASH_INPUT_SIZE - cx->klen);\r\n\r\n /* xor ipad into key value */\r\n for(i = 0; i < (HASH_INPUT_SIZE >> 2); ++i)\r\n ((uint_32t*)cx->key)[i] ^= 0x36363636;\r\n\r\n /* and start hash operation */\r\n sha_begin(cx->ctx);\r\n sha_hash(cx->key, HASH_INPUT_SIZE, cx->ctx);\r\n\r\n /* mark as now in data mode */\r\n cx->klen = HMAC_IN_DATA;\r\n }\r\n\r\n /* hash the data (if any) */\r\n if(data_len)\r\n sha_hash(data, data_len, cx->ctx);\r\n}\r\n\r\n/* compute and output the MAC value */\r\nvoid hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1])\r\n{ unsigned char dig[HASH_OUTPUT_SIZE];\r\n unsigned int i;\r\n\r\n /* if no data has been entered perform a null data phase */\r\n if(cx->klen != HMAC_IN_DATA)\r\n hmac_sha_data((const unsigned char*)0, 0, cx);\r\n\r\n sha_end(dig, cx->ctx); /* complete the inner hash */\r\n\r\n /* set outer key value using opad and removing ipad */\r\n for(i = 0; i < (HASH_INPUT_SIZE >> 2); ++i)\r\n ((uint_32t*)cx->key)[i] ^= 0x36363636 ^ 0x5c5c5c5c;\r\n\r\n /* perform the outer hash operation */\r\n sha_begin(cx->ctx);\r\n sha_hash(cx->key, HASH_INPUT_SIZE, cx->ctx);\r\n sha_hash(dig, HASH_OUTPUT_SIZE, cx->ctx);\r\n sha_end(dig, cx->ctx);\r\n\r\n /* output the hash value */\r\n for(i = 0; i < mac_len; ++i)\r\n mac[i] = dig[i];\r\n}\r\n\r\n/* 'do it all in one go' subroutine */\r\nvoid hmac_sha(const unsigned char key[], unsigned long key_len,\r\n const unsigned char data[], unsigned long data_len,\r\n unsigned char mac[], unsigned long mac_len)\r\n{ hmac_ctx cx[1];\r\n\r\n hmac_sha_begin(cx);\r\n hmac_sha_key(key, key_len, cx);\r\n hmac_sha_data(data, data_len, cx);\r\n hmac_sha_end(mac, mac_len, cx);\r\n}\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/hmac.h",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 26/08/2003\r\n\r\n This is an implementation of HMAC, the FIPS standard keyed hash function\r\n*/\r\n\r\n#ifndef _HMAC_H\r\n#define _HMAC_H\r\n\r\n#include <memory.h>\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#define USE_SHA1\r\n\r\n#if !defined(USE_SHA1) && !defined(USE_SHA256)\r\n#error define USE_SHA1 or USE_SHA256 to set the HMAC hash algorithm\r\n#endif\r\n\r\n#ifdef USE_SHA1\r\n\r\n#include \"sha1.h\"\r\n\r\n#define HASH_INPUT_SIZE SHA1_BLOCK_SIZE\r\n#define HASH_OUTPUT_SIZE SHA1_DIGEST_SIZE\r\n#define sha_ctx sha1_ctx\r\n#define sha_begin sha1_begin\r\n#define sha_hash sha1_hash\r\n#define sha_end sha1_end\r\n\r\n#endif\r\n\r\n#ifdef USE_SHA256\r\n\r\n#include \"sha2.h\"\r\n\r\n#define HASH_INPUT_SIZE SHA256_BLOCK_SIZE\r\n#define HASH_OUTPUT_SIZE SHA256_DIGEST_SIZE\r\n#define sha_ctx sha256_ctx\r\n#define sha_begin sha256_begin\r\n#define sha_hash sha256_hash\r\n#define sha_end sha256_end\r\n\r\n#endif\r\n\r\n#define HMAC_OK 0\r\n#define HMAC_BAD_MODE -1\r\n#define HMAC_IN_DATA 0xffffffff\r\n\r\ntypedef struct\r\n{ unsigned char key[HASH_INPUT_SIZE];\r\n sha_ctx ctx[1];\r\n unsigned long klen;\r\n} hmac_ctx;\r\n\r\nvoid hmac_sha_begin(hmac_ctx cx[1]);\r\n\r\nint hmac_sha_key(const unsigned char key[], unsigned long key_len, hmac_ctx cx[1]);\r\n\r\nvoid hmac_sha_data(const unsigned char data[], unsigned long data_len, hmac_ctx cx[1]);\r\n\r\nvoid hmac_sha_end(unsigned char mac[], unsigned long mac_len, hmac_ctx cx[1]);\r\n\r\nvoid hmac_sha(const unsigned char key[], unsigned long key_len,\r\n const unsigned char data[], unsigned long data_len,\r\n unsigned char mac[], unsigned long mac_len);\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/prng.c",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK.\r\n All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 24/01/2003\r\n\r\n This file implements a random data pool based on the use of an external\r\n entropy function. It is based on the ideas advocated by Peter Gutmann in\r\n his work on pseudo random sequence generators. It is not a 'paranoid'\r\n random sequence generator and no attempt is made to protect the pool\r\n from prying eyes either by memory locking or by techniques to obscure\r\n its location in memory.\r\n*/\r\n\r\n#include <memory.h>\r\n#include \"prng.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* mix a random data pool using the SHA1 compression function (as */\r\n/* suggested by Peter Gutmann in his paper on random pools) */\r\n\r\nstatic void prng_mix(unsigned char buf[])\r\n{ unsigned int i, len;\r\n sha1_ctx ctx[1];\r\n\r\n /*lint -e{663} unusual array to pointer conversion */\r\n for(i = 0; i < PRNG_POOL_SIZE; i += SHA1_DIGEST_SIZE)\r\n {\r\n /* copy digest size pool block into SHA1 hash block */\r\n memcpy(ctx->hash, buf + (i ? i : PRNG_POOL_SIZE)\r\n - SHA1_DIGEST_SIZE, SHA1_DIGEST_SIZE);\r\n\r\n /* copy data from pool into the SHA1 data buffer */\r\n len = PRNG_POOL_SIZE - i;\r\n memcpy(ctx->wbuf, buf + i, (len > SHA1_BLOCK_SIZE ? SHA1_BLOCK_SIZE : len));\r\n\r\n if(len < SHA1_BLOCK_SIZE)\r\n memcpy(((char*)ctx->wbuf) + len, buf, SHA1_BLOCK_SIZE - len);\r\n\r\n /* compress using the SHA1 compression function */\r\n sha1_compile(ctx);\r\n\r\n /* put digest size block back into the random pool */\r\n memcpy(buf + i, ctx->hash, SHA1_DIGEST_SIZE);\r\n }\r\n}\r\n\r\n/* refresh the output buffer and update the random pool by adding */\r\n/* entropy and remixing */\r\n\r\nstatic void update_pool(prng_ctx ctx[1])\r\n{ unsigned int i = 0;\r\n\r\n /* transfer random pool data to the output buffer */\r\n memcpy(ctx->obuf, ctx->rbuf, PRNG_POOL_SIZE);\r\n\r\n /* enter entropy data into the pool */\r\n while(i < PRNG_POOL_SIZE)\r\n i += ctx->entropy(ctx->rbuf + i, PRNG_POOL_SIZE - i);\r\n\r\n /* invert and xor the original pool data into the pool */\r\n for(i = 0; i < PRNG_POOL_SIZE; ++i)\r\n ctx->rbuf[i] ^= ~ctx->obuf[i];\r\n\r\n /* mix the pool and the output buffer */\r\n prng_mix(ctx->rbuf);\r\n prng_mix(ctx->obuf);\r\n}\r\n\r\nvoid prng_init(prng_entropy_fn fun, prng_ctx ctx[1])\r\n{ int i;\r\n\r\n /* clear the buffers and the counter in the context */\r\n memset(ctx, 0, sizeof(prng_ctx));\r\n\r\n /* set the pointer to the entropy collection function */\r\n ctx->entropy = fun;\r\n\r\n /* initialise the random data pool */\r\n update_pool(ctx);\r\n\r\n /* mix the pool a minimum number of times */\r\n for(i = 0; i < PRNG_MIN_MIX; ++i)\r\n prng_mix(ctx->rbuf);\r\n\r\n /* update the pool to prime the pool output buffer */\r\n update_pool(ctx);\r\n}\r\n\r\n/* provide random bytes from the random data pool */\r\n\r\nvoid prng_rand(unsigned char data[], unsigned int data_len, prng_ctx ctx[1])\r\n{ unsigned char *rp = data;\r\n unsigned int len, pos = ctx->pos;\r\n\r\n while(data_len)\r\n {\r\n /* transfer 'data_len' bytes (or the number of bytes remaining */\r\n /* the pool output buffer if less) into the output */\r\n len = (data_len < PRNG_POOL_SIZE - pos ? data_len : PRNG_POOL_SIZE - pos);\r\n memcpy(rp, ctx->obuf + pos, len);\r\n rp += len; /* update ouput buffer position pointer */\r\n pos += len; /* update pool output buffer pointer */\r\n data_len -= len; /* update the remaining data count */\r\n\r\n /* refresh the random pool if necessary */\r\n if(pos == PRNG_POOL_SIZE)\r\n {\r\n update_pool(ctx); pos = 0;\r\n }\r\n }\r\n\r\n ctx->pos = pos;\r\n}\r\n\r\nvoid prng_end(prng_ctx ctx[1])\r\n{\r\n /* ensure the data in the context is destroyed */\r\n memset(ctx, 0, sizeof(prng_ctx));\r\n}\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n"
},
{
"path": "libs/minizip/source/aes/prng.h",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman < >, Worcester, UK.\r\n All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 24/01/2003\r\n\r\n This is the header file for an implementation of a random data pool based on\r\n the use of an external entropy function (inspired by Peter Gutmann's work).\r\n*/\r\n\r\n#ifndef _PRNG_H\r\n#define _PRNG_H\r\n\r\n#include \"sha1.h\"\r\n\r\n#define PRNG_POOL_LEN 256 /* minimum random pool size */\r\n#define PRNG_MIN_MIX 20 /* min initial pool mixing iterations */\r\n\r\n/* ensure that pool length is a multiple of the SHA1 digest size */\r\n\r\n#define PRNG_POOL_SIZE (SHA1_DIGEST_SIZE * (1 + (PRNG_POOL_LEN - 1) / SHA1_DIGEST_SIZE))\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* A function for providing entropy is a parameter in the prng_init() */\r\n/* call. This function has the following form and returns a maximum */\r\n/* of 'len' bytes of pseudo random data in the buffer 'buf'. It can */\r\n/* return less than 'len' bytes but will be repeatedly called for more */\r\n/* data in this case. */\r\n\r\ntypedef int (*prng_entropy_fn)(unsigned char buf[], unsigned int len);\r\n\r\ntypedef struct\r\n{ unsigned char rbuf[PRNG_POOL_SIZE]; /* the random pool */\r\n unsigned char obuf[PRNG_POOL_SIZE]; /* pool output buffer */\r\n unsigned int pos; /* output buffer position */\r\n prng_entropy_fn entropy; /* entropy function pointer */\r\n} prng_ctx;\r\n\r\n/* initialise the random stream generator */\r\nvoid prng_init(prng_entropy_fn fun, prng_ctx ctx[1]);\r\n\r\n/* obtain random bytes from the generator */\r\nvoid prng_rand(unsigned char data[], unsigned int data_len, prng_ctx ctx[1]);\r\n\r\n/* close the random stream generator */\r\nvoid prng_end(prng_ctx ctx[1]);\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/pwd2key.c",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 26/08/2003\r\n\r\n This is an implementation of RFC2898, which specifies key derivation from\r\n a password and a salt value.\r\n*/\r\n\r\n#include <memory.h>\r\n#include \"hmac.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\nvoid derive_key(const unsigned char pwd[], /* the PASSWORD */\r\n unsigned int pwd_len, /* and its length */\r\n const unsigned char salt[], /* the SALT and its */\r\n unsigned int salt_len, /* length */\r\n unsigned int iter, /* the number of iterations */\r\n unsigned char key[], /* space for the output key */\r\n unsigned int key_len)/* and its required length */\r\n{\r\n unsigned int i, j, k, n_blk;\r\n unsigned char uu[HASH_OUTPUT_SIZE], ux[HASH_OUTPUT_SIZE];\r\n hmac_ctx c1[1], c2[1], c3[1];\r\n\r\n /* set HMAC context (c1) for password */\r\n hmac_sha_begin(c1);\r\n hmac_sha_key(pwd, pwd_len, c1);\r\n\r\n /* set HMAC context (c2) for password and salt */\r\n memcpy(c2, c1, sizeof(hmac_ctx));\r\n hmac_sha_data(salt, salt_len, c2);\r\n\r\n /* find the number of SHA blocks in the key */\r\n n_blk = 1 + (key_len - 1) / HASH_OUTPUT_SIZE;\r\n\r\n for(i = 0; i < n_blk; ++i) /* for each block in key */\r\n {\r\n /* ux[] holds the running xor value */\r\n memset(ux, 0, HASH_OUTPUT_SIZE);\r\n\r\n /* set HMAC context (c3) for password and salt */\r\n memcpy(c3, c2, sizeof(hmac_ctx));\r\n\r\n /* enter additional data for 1st block into uu */\r\n uu[0] = (unsigned char)((i + 1) >> 24);\r\n uu[1] = (unsigned char)((i + 1) >> 16);\r\n uu[2] = (unsigned char)((i + 1) >> 8);\r\n uu[3] = (unsigned char)(i + 1);\r\n\r\n /* this is the key mixing iteration */\r\n for(j = 0, k = 4; j < iter; ++j)\r\n {\r\n /* add previous round data to HMAC */\r\n hmac_sha_data(uu, k, c3);\r\n\r\n /* obtain HMAC for uu[] */\r\n hmac_sha_end(uu, HASH_OUTPUT_SIZE, c3);\r\n\r\n /* xor into the running xor block */\r\n for(k = 0; k < HASH_OUTPUT_SIZE; ++k)\r\n ux[k] ^= uu[k];\r\n\r\n /* set HMAC context (c3) for password */\r\n memcpy(c3, c1, sizeof(hmac_ctx));\r\n }\r\n\r\n /* compile key blocks into the key output */\r\n j = 0; k = i * HASH_OUTPUT_SIZE;\r\n while(j < HASH_OUTPUT_SIZE && k < key_len)\r\n key[k++] = ux[j++];\r\n }\r\n}\r\n\r\n#ifdef TEST\r\n\r\n#include <stdio.h>\r\n\r\nstruct\r\n{ unsigned int pwd_len;\r\n unsigned int salt_len;\r\n unsigned int it_count;\r\n unsigned char *pwd;\r\n unsigned char salt[32];\r\n unsigned char key[32];\r\n} tests[] =\r\n{\r\n { 8, 4, 5, (unsigned char*)\"password\",\r\n { \r\n 0x12, 0x34, 0x56, 0x78 \r\n },\r\n { \r\n 0x5c, 0x75, 0xce, 0xf0, 0x1a, 0x96, 0x0d, 0xf7,\r\n 0x4c, 0xb6, 0xb4, 0x9b, 0x9e, 0x38, 0xe6, 0xb5 \r\n }\r\n },\r\n { 8, 8, 5, (unsigned char*)\"password\",\r\n { \r\n 0x12, 0x34, 0x56, 0x78, 0x78, 0x56, 0x34, 0x12 \r\n },\r\n { \r\n 0xd1, 0xda, 0xa7, 0x86, 0x15, 0xf2, 0x87, 0xe6,\r\n 0xa1, 0xc8, 0xb1, 0x20, 0xd7, 0x06, 0x2a, 0x49 \r\n }\r\n },\r\n { 8, 21, 1, (unsigned char*)\"password\",\r\n {\r\n \"ATHENA.MIT.EDUraeburn\"\r\n },\r\n {\r\n 0xcd, 0xed, 0xb5, 0x28, 0x1b, 0xb2, 0xf8, 0x01,\r\n 0x56, 0x5a, 0x11, 0x22, 0xb2, 0x56, 0x35, 0x15\r\n }\r\n },\r\n { 8, 21, 2, (unsigned char*)\"password\",\r\n {\r\n \"ATHENA.MIT.EDUraeburn\"\r\n },\r\n {\r\n 0x01, 0xdb, 0xee, 0x7f, 0x4a, 0x9e, 0x24, 0x3e, \r\n 0x98, 0x8b, 0x62, 0xc7, 0x3c, 0xda, 0x93, 0x5d\r\n }\r\n },\r\n { 8, 21, 1200, (unsigned char*)\"password\",\r\n {\r\n \"ATHENA.MIT.EDUraeburn\"\r\n },\r\n {\r\n 0x5c, 0x08, 0xeb, 0x61, 0xfd, 0xf7, 0x1e, 0x4e, \r\n 0x4e, 0xc3, 0xcf, 0x6b, 0xa1, 0xf5, 0x51, 0x2b\r\n }\r\n }\r\n};\r\n\r\nint main()\r\n{ unsigned int i, j, key_len = 256;\r\n unsigned char key[256];\r\n\r\n printf(\"\\nTest of RFC2898 Password Based Key Derivation\");\r\n for(i = 0; i < 5; ++i)\r\n {\r\n derive_key(tests[i].pwd, tests[i].pwd_len, tests[i].salt,\r\n tests[i].salt_len, tests[i].it_count, key, key_len);\r\n\r\n printf(\"\\ntest %i: \", i + 1);\r\n printf(\"key %s\", memcmp(tests[i].key, key, 16) ? \"is bad\" : \"is good\");\r\n for(j = 0; j < key_len && j < 64; j += 4)\r\n {\r\n if(j % 16 == 0)\r\n printf(\"\\n\");\r\n printf(\"0x%02x%02x%02x%02x \", key[j], key[j + 1], key[j + 2], key[j + 3]);\r\n }\r\n printf(j < key_len ? \" ... \\n\" : \"\\n\");\r\n }\r\n printf(\"\\n\");\r\n return 0;\r\n}\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/pwd2key.h",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary \r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright \r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products \r\n built using this software without specific written permission. \r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n \r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness \r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 26/08/2003\r\n\r\n This is an implementation of RFC2898, which specifies key derivation from\r\n a password and a salt value.\r\n*/\r\n\r\n#ifndef PWD2KEY_H\r\n#define PWD2KEY_H\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\nvoid derive_key(\r\n const unsigned char pwd[], /* the PASSWORD, and */\r\n unsigned int pwd_len, /* its length */ \r\n const unsigned char salt[], /* the SALT and its */\r\n unsigned int salt_len, /* length */\r\n unsigned int iter, /* the number of iterations */\r\n unsigned char key[], /* space for the output key */\r\n unsigned int key_len); /* and its required length */\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/sha1.c",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 01/08/2005\r\n\r\n This is a byte oriented version of SHA1 that operates on arrays of bytes\r\n stored in memory.\r\n*/\r\n\r\n#include <string.h> /* for memcpy() etc. */\r\n\r\n#include \"sha1.h\"\r\n#include \"brg_endian.h\"\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n#if defined( _MSC_VER ) && ( _MSC_VER > 800 )\r\n#pragma intrinsic(memcpy)\r\n#endif\r\n\r\n#if 0 && defined(_MSC_VER)\r\n#define rotl32 _lrotl\r\n#define rotr32 _lrotr\r\n#else\r\n#define rotl32(x,n) (((x) << n) | ((x) >> (32 - n)))\r\n#define rotr32(x,n) (((x) >> n) | ((x) << (32 - n)))\r\n#endif\r\n\r\n#if !defined(bswap_32)\r\n#define bswap_32(x) ((rotr32((x), 24) & 0x00ff00ff) | (rotr32((x), 8) & 0xff00ff00))\r\n#endif\r\n\r\n#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)\r\n#define SWAP_BYTES\r\n#else\r\n#undef SWAP_BYTES\r\n#endif\r\n\r\n#if defined(SWAP_BYTES)\r\n#define bsw_32(p,n) \\\r\n { int _i = (n); while(_i--) ((uint_32t*)p)[_i] = bswap_32(((uint_32t*)p)[_i]); }\r\n#else\r\n#define bsw_32(p,n)\r\n#endif\r\n\r\n#define SHA1_MASK (SHA1_BLOCK_SIZE - 1)\r\n\r\n#if 0\r\n\r\n#define ch(x,y,z) (((x) & (y)) ^ (~(x) & (z)))\r\n#define parity(x,y,z) ((x) ^ (y) ^ (z))\r\n#define maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))\r\n\r\n#else /* Discovered by Rich Schroeppel and Colin Plumb */\r\n\r\n#define ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))\r\n#define parity(x,y,z) ((x) ^ (y) ^ (z))\r\n#define maj(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))\r\n\r\n#endif\r\n\r\n/* Compile 64 bytes of hash data into SHA1 context. Note */\r\n/* that this routine assumes that the byte order in the */\r\n/* ctx->wbuf[] at this point is in such an order that low */\r\n/* address bytes in the ORIGINAL byte stream will go in */\r\n/* this buffer to the high end of 32-bit words on BOTH big */\r\n/* and little endian systems */\r\n\r\n#ifdef ARRAY\r\n#define q(v,n) v[n]\r\n#else\r\n#define q(v,n) v##n\r\n#endif\r\n\r\n#define one_cycle(v,a,b,c,d,e,f,k,h) \\\r\n q(v,e) += rotr32(q(v,a),27) + \\\r\n f(q(v,b),q(v,c),q(v,d)) + k + h; \\\r\n q(v,b) = rotr32(q(v,b), 2)\r\n\r\n#define five_cycle(v,f,k,i) \\\r\n one_cycle(v, 0,1,2,3,4, f,k,hf(i )); \\\r\n one_cycle(v, 4,0,1,2,3, f,k,hf(i+1)); \\\r\n one_cycle(v, 3,4,0,1,2, f,k,hf(i+2)); \\\r\n one_cycle(v, 2,3,4,0,1, f,k,hf(i+3)); \\\r\n one_cycle(v, 1,2,3,4,0, f,k,hf(i+4))\r\n\r\nVOID_RETURN sha1_compile(sha1_ctx ctx[1])\r\n{ uint_32t *w = ctx->wbuf;\r\n\r\n#ifdef ARRAY\r\n uint_32t v[5];\r\n memcpy(v, ctx->hash, 5 * sizeof(uint_32t));\r\n#else\r\n uint_32t v0, v1, v2, v3, v4;\r\n v0 = ctx->hash[0]; v1 = ctx->hash[1];\r\n v2 = ctx->hash[2]; v3 = ctx->hash[3];\r\n v4 = ctx->hash[4];\r\n#endif\r\n\r\n#define hf(i) w[i]\r\n\r\n five_cycle(v, ch, 0x5a827999, 0);\r\n five_cycle(v, ch, 0x5a827999, 5);\r\n five_cycle(v, ch, 0x5a827999, 10);\r\n one_cycle(v,0,1,2,3,4, ch, 0x5a827999, hf(15)); \\\r\n\r\n#undef hf\r\n#define hf(i) (w[(i) & 15] = rotl32( \\\r\n w[((i) + 13) & 15] ^ w[((i) + 8) & 15] \\\r\n ^ w[((i) + 2) & 15] ^ w[(i) & 15], 1))\r\n\r\n one_cycle(v,4,0,1,2,3, ch, 0x5a827999, hf(16));\r\n one_cycle(v,3,4,0,1,2, ch, 0x5a827999, hf(17));\r\n one_cycle(v,2,3,4,0,1, ch, 0x5a827999, hf(18));\r\n one_cycle(v,1,2,3,4,0, ch, 0x5a827999, hf(19));\r\n\r\n five_cycle(v, parity, 0x6ed9eba1, 20);\r\n five_cycle(v, parity, 0x6ed9eba1, 25);\r\n five_cycle(v, parity, 0x6ed9eba1, 30);\r\n five_cycle(v, parity, 0x6ed9eba1, 35);\r\n\r\n five_cycle(v, maj, 0x8f1bbcdc, 40);\r\n five_cycle(v, maj, 0x8f1bbcdc, 45);\r\n five_cycle(v, maj, 0x8f1bbcdc, 50);\r\n five_cycle(v, maj, 0x8f1bbcdc, 55);\r\n\r\n five_cycle(v, parity, 0xca62c1d6, 60);\r\n five_cycle(v, parity, 0xca62c1d6, 65);\r\n five_cycle(v, parity, 0xca62c1d6, 70);\r\n five_cycle(v, parity, 0xca62c1d6, 75);\r\n\r\n#ifdef ARRAY\r\n ctx->hash[0] += v[0]; ctx->hash[1] += v[1];\r\n ctx->hash[2] += v[2]; ctx->hash[3] += v[3];\r\n ctx->hash[4] += v[4];\r\n#else\r\n ctx->hash[0] += v0; ctx->hash[1] += v1;\r\n ctx->hash[2] += v2; ctx->hash[3] += v3;\r\n ctx->hash[4] += v4;\r\n#endif\r\n}\r\n\r\nVOID_RETURN sha1_begin(sha1_ctx ctx[1])\r\n{\r\n ctx->count[0] = ctx->count[1] = 0;\r\n ctx->hash[0] = 0x67452301;\r\n ctx->hash[1] = 0xefcdab89;\r\n ctx->hash[2] = 0x98badcfe;\r\n ctx->hash[3] = 0x10325476;\r\n ctx->hash[4] = 0xc3d2e1f0;\r\n}\r\n\r\n/* SHA1 hash data in an array of bytes into hash buffer and */\r\n/* call the hash_compile function as required. */\r\n\r\nVOID_RETURN sha1_hash(const unsigned char data[], unsigned long len, sha1_ctx ctx[1])\r\n{ uint_32t pos = (uint_32t)(ctx->count[0] & SHA1_MASK),\r\n space = SHA1_BLOCK_SIZE - pos;\r\n const unsigned char *sp = data;\r\n\r\n if((ctx->count[0] += len) < len)\r\n ++(ctx->count[1]);\r\n\r\n while(len >= space) /* tranfer whole blocks if possible */\r\n {\r\n memcpy(((unsigned char*)ctx->wbuf) + pos, sp, space);\r\n sp += space; len -= space; space = SHA1_BLOCK_SIZE; pos = 0;\r\n bsw_32(ctx->wbuf, SHA1_BLOCK_SIZE >> 2);\r\n sha1_compile(ctx);\r\n }\r\n\r\n memcpy(((unsigned char*)ctx->wbuf) + pos, sp, len);\r\n}\r\n\r\n/* SHA1 final padding and digest calculation */\r\n\r\nVOID_RETURN sha1_end(unsigned char hval[], sha1_ctx ctx[1])\r\n{ uint_32t i = (uint_32t)(ctx->count[0] & SHA1_MASK);\r\n\r\n /* put bytes in the buffer in an order in which references to */\r\n /* 32-bit words will put bytes with lower addresses into the */\r\n /* top of 32 bit words on BOTH big and little endian machines */\r\n bsw_32(ctx->wbuf, (i + 3) >> 2);\r\n\r\n /* we now need to mask valid bytes and add the padding which is */\r\n /* a single 1 bit and as many zero bits as necessary. Note that */\r\n /* we can always add the first padding byte here because the */\r\n /* buffer always has at least one empty slot */\r\n ctx->wbuf[i >> 2] &= 0xffffff80 << 8 * (~i & 3);\r\n ctx->wbuf[i >> 2] |= 0x00000080 << 8 * (~i & 3);\r\n\r\n /* we need 9 or more empty positions, one for the padding byte */\r\n /* (above) and eight for the length count. If there is not */\r\n /* enough space, pad and empty the buffer */\r\n if(i > SHA1_BLOCK_SIZE - 9)\r\n {\r\n if(i < 60) ctx->wbuf[15] = 0;\r\n sha1_compile(ctx);\r\n i = 0;\r\n }\r\n else /* compute a word index for the empty buffer positions */\r\n i = (i >> 2) + 1;\r\n\r\n while(i < 14) /* and zero pad all but last two positions */\r\n ctx->wbuf[i++] = 0;\r\n\r\n /* the following 32-bit length fields are assembled in the */\r\n /* wrong byte order on little endian machines but this is */\r\n /* corrected later since they are only ever used as 32-bit */\r\n /* word values. */\r\n ctx->wbuf[14] = (ctx->count[1] << 3) | (ctx->count[0] >> 29);\r\n ctx->wbuf[15] = ctx->count[0] << 3;\r\n sha1_compile(ctx);\r\n\r\n /* extract the hash value as bytes in case the hash buffer is */\r\n /* misaligned for 32-bit words */\r\n for(i = 0; i < SHA1_DIGEST_SIZE; ++i)\r\n hval[i] = (unsigned char)(ctx->hash[i >> 2] >> (8 * (~i & 3)));\r\n}\r\n\r\nVOID_RETURN sha1(unsigned char hval[], const unsigned char data[], unsigned long len)\r\n{ sha1_ctx cx[1];\r\n\r\n sha1_begin(cx); sha1_hash(data, len, cx); sha1_end(hval, cx);\r\n}\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/aes/sha1.h",
"content": "/*\r\n ---------------------------------------------------------------------------\r\n Copyright (c) 2002, Dr Brian Gladman, Worcester, UK. All rights reserved.\r\n\r\n LICENSE TERMS\r\n\r\n The free distribution and use of this software in both source and binary\r\n form is allowed (with or without changes) provided that:\r\n\r\n 1. distributions of this source code include the above copyright\r\n notice, this list of conditions and the following disclaimer;\r\n\r\n 2. distributions in binary form include the above copyright\r\n notice, this list of conditions and the following disclaimer\r\n in the documentation and/or other associated materials;\r\n\r\n 3. the copyright holder's name is not used to endorse products\r\n built using this software without specific written permission.\r\n\r\n ALTERNATIVELY, provided that this notice is retained in full, this product\r\n may be distributed under the terms of the GNU General Public License (GPL),\r\n in which case the provisions of the GPL apply INSTEAD OF those given above.\r\n\r\n DISCLAIMER\r\n\r\n This software is provided 'as is' with no explicit or implied warranties\r\n in respect of its properties, including, but not limited to, correctness\r\n and/or fitness for purpose.\r\n ---------------------------------------------------------------------------\r\n Issue Date: 01/08/2005\r\n*/\r\n\r\n#ifndef _SHA1_H\r\n#define _SHA1_H\r\n\r\n#include <stdlib.h>\r\n#include \"brg_types.h\"\r\n\r\n#define SHA1_BLOCK_SIZE 64\r\n#define SHA1_DIGEST_SIZE 20\r\n\r\n#if defined(__cplusplus)\r\nextern \"C\"\r\n{\r\n#endif\r\n\r\n/* type to hold the SHA256 context */\r\n\r\ntypedef struct\r\n{ uint_32t count[2];\r\n uint_32t hash[5];\r\n uint_32t wbuf[16];\r\n} sha1_ctx;\r\n\r\n/* Note that these prototypes are the same for both bit and */\r\n/* byte oriented implementations. However the length fields */\r\n/* are in bytes or bits as appropriate for the version used */\r\n/* and bit sequences are input as arrays of bytes in which */\r\n/* bit sequences run from the most to the least significant */\r\n/* end of each byte */\r\n\r\nVOID_RETURN sha1_compile(sha1_ctx ctx[1]);\r\n\r\nVOID_RETURN sha1_begin(sha1_ctx ctx[1]);\r\nVOID_RETURN sha1_hash(const unsigned char data[], unsigned long len, sha1_ctx ctx[1]);\r\nVOID_RETURN sha1_end(unsigned char hval[], sha1_ctx ctx[1]);\r\nVOID_RETURN sha1(unsigned char hval[], const unsigned char data[], unsigned long len);\r\n\r\n#if defined(__cplusplus)\r\n}\r\n#endif\r\n\r\n#endif\r\n"
},
{
"path": "libs/minizip/source/ioapi.c",
"content": "/* ioapi.h -- IO base function header for compress/uncompress .zip\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications for Zip64 support\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n#include \"ioapi.h\"\r\n\r\n#if defined(_WIN32)\r\n# define snprintf _snprintf\r\n#endif\r\n\r\n#ifdef __APPLE__\r\n/* In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions */\r\n# define FOPEN_FUNC(filename, mode) fopen(filename, mode)\r\n# define FTELLO_FUNC(stream) ftello(stream)\r\n# define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)\r\n#else\r\n# define FOPEN_FUNC(filename, mode) fopen64(filename, mode)\r\n# define FTELLO_FUNC(stream) ftello64(stream)\r\n# define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)\r\n#endif\r\n\r\n/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */\r\n#ifndef SEEK_CUR\r\n# define SEEK_CUR 1\r\n#endif\r\n#ifndef SEEK_END\r\n# define SEEK_END 2\r\n#endif\r\n#ifndef SEEK_SET\r\n# define SEEK_SET 0\r\n#endif\r\n\r\nvoidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)\r\n{\r\n if (pfilefunc->zfile_func64.zopen64_file != NULL)\r\n return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);\r\n return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);\r\n}\r\n\r\nvoidpf call_zopendisk64 OF((const zlib_filefunc64_32_def* pfilefunc, voidpf filestream, int number_disk, int mode))\r\n{\r\n if (pfilefunc->zfile_func64.zopendisk64_file != NULL)\r\n return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque,filestream,number_disk,mode);\r\n return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque,filestream,number_disk,mode);\r\n}\r\n\r\nlong call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)\r\n{\r\n uLong offsetTruncated;\r\n if (pfilefunc->zfile_func64.zseek64_file != NULL)\r\n return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);\r\n offsetTruncated = (uLong)offset;\r\n if (offsetTruncated != offset)\r\n return -1;\r\n return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);\r\n}\r\n\r\nZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)\r\n{\r\n uLong tell_uLong;\r\n if (pfilefunc->zfile_func64.zseek64_file != NULL)\r\n return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);\r\n tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);\r\n if ((tell_uLong) == 0xffffffff)\r\n return (ZPOS64_T)-1;\r\n return tell_uLong;\r\n}\r\n\r\nvoid fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)\r\n{\r\n p_filefunc64_32->zfile_func64.zopen64_file = NULL;\r\n p_filefunc64_32->zfile_func64.zopendisk64_file = NULL;\r\n p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;\r\n p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file;\r\n p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;\r\n p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;\r\n p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;\r\n p_filefunc64_32->zfile_func64.ztell64_file = NULL;\r\n p_filefunc64_32->zfile_func64.zseek64_file = NULL;\r\n p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;\r\n p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;\r\n p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;\r\n p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;\r\n p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;\r\n}\r\n\r\nstatic voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));\r\nstatic uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));\r\nstatic uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));\r\nstatic ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));\r\nstatic long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));\r\nstatic int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));\r\nstatic int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));\r\n\r\ntypedef struct \r\n{\r\n FILE *file;\r\n int filenameLength;\r\n void *filename;\r\n} FILE_IOPOSIX;\r\n\r\nstatic voidpf file_build_ioposix(FILE *file, const char *filename)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n if (file == NULL)\r\n return NULL;\r\n ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX));\r\n ioposix->file = file;\r\n ioposix->filenameLength = strlen(filename) + 1;\r\n ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char));\r\n strncpy(ioposix->filename, filename, ioposix->filenameLength);\r\n return (voidpf)ioposix;\r\n}\r\n\r\nstatic voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)\r\n{\r\n FILE* file = NULL;\r\n const char* mode_fopen = NULL;\r\n if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)\r\n mode_fopen = \"rb\";\r\n else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)\r\n mode_fopen = \"r+b\";\r\n else if (mode & ZLIB_FILEFUNC_MODE_CREATE)\r\n mode_fopen = \"wb\";\r\n\r\n if ((filename != NULL) && (mode_fopen != NULL))\r\n {\r\n file = fopen(filename, mode_fopen);\r\n return file_build_ioposix(file, filename);\r\n }\r\n return file;\r\n}\r\n\r\nstatic voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)\r\n{\r\n FILE* file = NULL;\r\n const char* mode_fopen = NULL;\r\n if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ)\r\n mode_fopen = \"rb\";\r\n else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)\r\n mode_fopen = \"r+b\";\r\n else if (mode & ZLIB_FILEFUNC_MODE_CREATE)\r\n mode_fopen = \"wb\";\r\n\r\n if ((filename != NULL) && (mode_fopen != NULL))\r\n {\r\n file = FOPEN_FUNC((const char*)filename, mode_fopen);\r\n return file_build_ioposix(file, (const char*)filename);\r\n }\r\n return file;\r\n}\r\n\r\nstatic voidpf ZCALLBACK fopendisk64_file_func (voidpf opaque, voidpf stream, int number_disk, int mode)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n char *diskFilename = NULL;\r\n voidpf ret = NULL;\r\n int i = 0;\r\n\r\n if (stream == NULL)\r\n return NULL;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));\r\n strncpy(diskFilename, ioposix->filename, ioposix->filenameLength);\r\n for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)\r\n {\r\n if (diskFilename[i] != '.') \r\n continue;\r\n snprintf(&diskFilename[i], ioposix->filenameLength - i, \".z%02d\", number_disk + 1);\r\n break;\r\n }\r\n if (i >= 0)\r\n ret = fopen64_file_func(opaque, diskFilename, mode);\r\n free(diskFilename);\r\n return ret;\r\n}\r\n\r\nstatic voidpf ZCALLBACK fopendisk_file_func (voidpf opaque, voidpf stream, int number_disk, int mode)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n char *diskFilename = NULL;\r\n voidpf ret = NULL;\r\n int i = 0;\r\n\r\n if (stream == NULL)\r\n return NULL;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));\r\n strncpy(diskFilename, ioposix->filename, ioposix->filenameLength);\r\n for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)\r\n {\r\n if (diskFilename[i] != '.') \r\n continue;\r\n snprintf(&diskFilename[i], ioposix->filenameLength - i, \".z%02d\", number_disk + 1);\r\n break;\r\n }\r\n if (i >= 0)\r\n ret = fopen_file_func(opaque, diskFilename, mode);\r\n free(diskFilename);\r\n return ret;\r\n}\r\n\r\nstatic uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n uLong ret;\r\n if (stream == NULL)\r\n return -1;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n ret = (uLong)fread(buf, 1, (size_t)size, ioposix->file);\r\n return ret;\r\n}\r\n\r\nstatic uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n uLong ret;\r\n if (stream == NULL)\r\n return -1;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n ret = (uLong)fwrite(buf, 1, (size_t)size, ioposix->file);\r\n return ret;\r\n}\r\n\r\nstatic long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n long ret = -1;\r\n if (stream == NULL)\r\n return ret;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n ret = ftell(ioposix->file);\r\n return ret;\r\n}\r\n\r\nstatic ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n ZPOS64_T ret = -1;\r\n if (stream == NULL)\r\n return ret;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n ret = FTELLO_FUNC(ioposix->file);\r\n return ret;\r\n}\r\n\r\nstatic long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n int fseek_origin = 0;\r\n long ret = 0;\r\n\r\n if (stream == NULL)\r\n return -1;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n\r\n switch (origin)\r\n {\r\n case ZLIB_FILEFUNC_SEEK_CUR:\r\n fseek_origin = SEEK_CUR;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_END:\r\n fseek_origin = SEEK_END;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_SET:\r\n fseek_origin = SEEK_SET;\r\n break;\r\n default:\r\n return -1;\r\n }\r\n if (fseek(ioposix->file, offset, fseek_origin) != 0)\r\n ret = -1;\r\n return ret;\r\n}\r\n\r\nstatic long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n int fseek_origin = 0;\r\n long ret = 0;\r\n\r\n if (stream == NULL)\r\n return -1;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n\r\n switch (origin)\r\n {\r\n case ZLIB_FILEFUNC_SEEK_CUR:\r\n fseek_origin = SEEK_CUR;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_END:\r\n fseek_origin = SEEK_END;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_SET:\r\n fseek_origin = SEEK_SET;\r\n break;\r\n default:\r\n return -1;\r\n }\r\n\r\n if(FSEEKO_FUNC(ioposix->file, offset, fseek_origin) != 0)\r\n ret = -1;\r\n\r\n return ret;\r\n}\r\n\r\n\r\nstatic int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n int ret = -1;\r\n if (stream == NULL)\r\n return ret;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n if (ioposix->filename != NULL)\r\n free(ioposix->filename);\r\n ret = fclose(ioposix->file);\r\n free(ioposix);\r\n return ret;\r\n}\r\n\r\nstatic int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)\r\n{\r\n FILE_IOPOSIX *ioposix = NULL;\r\n int ret = -1;\r\n if (stream == NULL)\r\n return ret;\r\n ioposix = (FILE_IOPOSIX*)stream;\r\n ret = ferror(ioposix->file);\r\n return ret;\r\n}\r\n\r\nvoid fill_fopen_filefunc (zlib_filefunc_def* pzlib_filefunc_def)\r\n{\r\n pzlib_filefunc_def->zopen_file = fopen_file_func;\r\n pzlib_filefunc_def->zopendisk_file = fopendisk_file_func;\r\n pzlib_filefunc_def->zread_file = fread_file_func;\r\n pzlib_filefunc_def->zwrite_file = fwrite_file_func;\r\n pzlib_filefunc_def->ztell_file = ftell_file_func;\r\n pzlib_filefunc_def->zseek_file = fseek_file_func;\r\n pzlib_filefunc_def->zclose_file = fclose_file_func;\r\n pzlib_filefunc_def->zerror_file = ferror_file_func;\r\n pzlib_filefunc_def->opaque = NULL;\r\n}\r\n\r\nvoid fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def)\r\n{\r\n pzlib_filefunc_def->zopen64_file = fopen64_file_func;\r\n pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func;\r\n pzlib_filefunc_def->zread_file = fread_file_func;\r\n pzlib_filefunc_def->zwrite_file = fwrite_file_func;\r\n pzlib_filefunc_def->ztell64_file = ftell64_file_func;\r\n pzlib_filefunc_def->zseek64_file = fseek64_file_func;\r\n pzlib_filefunc_def->zclose_file = fclose_file_func;\r\n pzlib_filefunc_def->zerror_file = ferror_file_func;\r\n pzlib_filefunc_def->opaque = NULL;\r\n}\r\n"
},
{
"path": "libs/minizip/source/ioapi_buf.c",
"content": "/* ioapi_buf.h -- IO base function header for compress/uncompress .zip\r\n files using zlib + zip or unzip API\r\n\r\n This version of ioapi is designed to buffer IO.\r\n\r\n Copyright (C) 1998-2003 Gilles Vollant\r\n (C) 2012-2014 Nathan Moinvaziri\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n#include <stdarg.h>\r\n\r\n#include \"zlib.h\"\r\n#include \"ioapi.h\"\r\n\r\n#include \"ioapi_buf.h\"\r\n\r\n#if defined(_WIN32)\r\n# include <conio.h>\r\n# define PRINTF _cprintf\r\n# define VPRINTF _vcprintf\r\n#else\r\n# define PRINTF printf\r\n# define VPRINTF vprintf\r\n#endif\r\n\r\n//#define IOBUF_VERBOSE\r\n\r\n#ifdef __GNUC__\r\n#ifndef max\r\n#define max(x,y) ({ \\\r\nconst typeof(x) _x = (x);\t\\\r\nconst typeof(y) _y = (y);\t\\\r\n(void) (&_x == &_y);\t\t\\\r\n_x > _y ? _x : _y; })\r\n#endif /* __GNUC__ */\r\n\r\n#ifndef min\r\n#define min(x,y) ({ \\\r\nconst typeof(x) _x = (x);\t\\\r\nconst typeof(y) _y = (y);\t\\\r\n(void) (&_x == &_y);\t\t\\\r\n_x < _y ? _x : _y; })\r\n#endif\r\n#endif\r\n\r\ntypedef struct ourstream_s {\r\n char readBuffer[IOBUF_BUFFERSIZE];\r\n uInt readBufferLength;\r\n uInt readBufferPos;\r\n uInt readBufferHits;\r\n uInt readBufferMisses;\r\n char writeBuffer[IOBUF_BUFFERSIZE];\r\n uInt writeBufferLength;\r\n uInt writeBufferPos;\r\n uInt writeBufferHits;\r\n uInt writeBufferMisses;\r\n ZPOS64_T position;\r\n voidpf stream;\r\n} ourstream_t;\r\n\r\n#if defined(IOBUF_VERBOSE)\r\n# define print_buf(o,s,f,...) print_buf_internal(o,s,f,__VA_ARGS__);\r\n#else\r\n# define print_buf(o,s,f,...)\r\n#endif \r\n\r\nvoid print_buf_internal(voidpf opaque, voidpf stream, char *format, ...)\r\n{\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n va_list arglist;\r\n PRINTF(\"Buf stream %p - \", streamio);\r\n va_start(arglist, format);\r\n VPRINTF(format, arglist);\r\n va_end(arglist);\r\n}\r\n\r\nvoidpf fopen_buf_internal_func (opaque, stream, number_disk, mode)\r\n voidpf opaque;\r\n voidpf stream;\r\n int number_disk;\r\n int mode;\r\n{\r\n ourstream_t *streamio = NULL;\r\n if (stream == NULL)\r\n return NULL;\r\n streamio = (ourstream_t *)malloc(sizeof(ourstream_t));\r\n if (streamio == NULL)\r\n return NULL;\r\n memset(streamio, 0, sizeof(ourstream_t));\r\n streamio->stream = stream;\r\n print_buf(opaque, streamio, \"open [num %d mode %d]\\n\", number_disk, mode);\r\n return streamio;\r\n}\r\n\r\nvoidpf ZCALLBACK fopen_buf_func (opaque, filename, mode)\r\n voidpf opaque;\r\n const char* filename;\r\n int mode;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n voidpf stream = bufio->filefunc.zopen_file(bufio->filefunc.opaque, filename, mode);\r\n return fopen_buf_internal_func(opaque, stream, 0, mode);\r\n}\r\n\r\nvoidpf ZCALLBACK fopen64_buf_func (opaque, filename, mode)\r\n voidpf opaque;\r\n const char* filename;\r\n int mode;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n voidpf stream = bufio->filefunc64.zopen64_file(bufio->filefunc64.opaque, filename, mode);\r\n return fopen_buf_internal_func(opaque, stream, 0, mode);\r\n}\r\n\r\nvoidpf ZCALLBACK fopendisk_buf_func (opaque, stream_cd, number_disk, mode)\r\n voidpf opaque;\r\n voidpf stream_cd;\r\n int number_disk;\r\n int mode;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream_cd;\r\n voidpf *stream = bufio->filefunc.zopendisk_file(bufio->filefunc.opaque, streamio->stream, number_disk, mode);\r\n return fopen_buf_internal_func(opaque, stream, number_disk, mode);\r\n}\r\n\r\nvoidpf ZCALLBACK fopendisk64_buf_func (opaque, stream_cd, number_disk, mode)\r\n voidpf opaque;\r\n voidpf stream_cd;\r\n int number_disk;\r\n int mode;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream_cd;\r\n voidpf stream = bufio->filefunc64.zopendisk64_file(bufio->filefunc64.opaque, streamio->stream, number_disk, mode);\r\n return fopen_buf_internal_func(opaque, stream, number_disk, mode);\r\n}\r\n\r\nlong fflush_buf OF((voidpf opaque, voidpf stream));\r\nlong fflush_buf (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n uInt totalBytesWritten = 0;\r\n uInt bytesToWrite = streamio->writeBufferLength;\r\n uInt bytesLeftToWrite = streamio->writeBufferLength;\r\n int bytesWritten = 0;\r\n \r\n while (bytesLeftToWrite > 0)\r\n {\r\n if (bufio->filefunc64.zwrite_file != NULL)\r\n bytesWritten = bufio->filefunc64.zwrite_file(bufio->filefunc64.opaque, streamio->stream, streamio->writeBuffer + (bytesToWrite - bytesLeftToWrite), bytesLeftToWrite);\r\n else\r\n bytesWritten = bufio->filefunc.zwrite_file(bufio->filefunc.opaque, streamio->stream, streamio->writeBuffer + (bytesToWrite - bytesLeftToWrite), bytesLeftToWrite);\r\n\r\n streamio->writeBufferMisses += 1;\r\n\r\n print_buf(opaque, stream, \"write flush [%d:%d len %d]\\n\", bytesToWrite, bytesLeftToWrite, streamio->writeBufferLength);\r\n\r\n if (bytesWritten < 0)\r\n return bytesWritten;\r\n\r\n totalBytesWritten += bytesWritten;\r\n bytesLeftToWrite -= bytesWritten;\r\n streamio->position += bytesWritten;\r\n }\r\n streamio->writeBufferLength = 0;\r\n streamio->writeBufferPos = 0;\r\n return totalBytesWritten;\r\n}\r\n\r\nuLong ZCALLBACK fread_buf_func (opaque, stream, buf, size)\r\n voidpf opaque;\r\n voidpf stream;\r\n void* buf;\r\n uLong size;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n uInt bytesToRead = 0;\r\n uInt bufLength = 0;\r\n uInt bytesToCopy = 0;\r\n uInt bytesLeftToRead = size;\r\n uInt bytesRead = -1;\r\n\r\n print_buf(opaque, stream, \"read [size %ld pos %lld]\\n\", size, streamio->position);\r\n\r\n if (streamio->writeBufferLength > 0)\r\n {\r\n print_buf(opaque, stream, \"switch from write to read, not yet supported [%lld]\\n\", streamio->position);\r\n }\r\n\r\n while (bytesLeftToRead > 0)\r\n {\r\n if ((streamio->readBufferLength == 0) || (streamio->readBufferPos == streamio->readBufferLength))\r\n {\r\n if (streamio->readBufferLength == IOBUF_BUFFERSIZE)\r\n {\r\n streamio->readBufferPos = 0;\r\n streamio->readBufferLength = 0;\r\n }\r\n\r\n bytesToRead = IOBUF_BUFFERSIZE -(streamio->readBufferLength - streamio->readBufferPos);\r\n\r\n if (bufio->filefunc64.zread_file != NULL)\r\n bytesRead = bufio->filefunc64.zread_file(bufio->filefunc64.opaque, streamio->stream, streamio->readBuffer + streamio->readBufferPos, bytesToRead);\r\n else\r\n bytesRead = bufio->filefunc.zread_file(bufio->filefunc.opaque, streamio->stream, streamio->readBuffer + streamio->readBufferPos, bytesToRead);\r\n\r\n streamio->readBufferMisses += 1;\r\n streamio->readBufferLength += bytesRead;\r\n streamio->position += bytesRead;\r\n\r\n print_buf(opaque, stream, \"filled [read %d/%d buf %d:%d pos %lld]\\n\", bytesRead, bytesToRead, streamio->readBufferPos, streamio->readBufferLength, streamio->position);\r\n\r\n if (bytesRead == 0)\r\n break;\r\n }\r\n\r\n if ((streamio->readBufferLength - streamio->readBufferPos) > 0)\r\n {\r\n bytesToCopy = min(bytesLeftToRead, (streamio->readBufferLength - streamio->readBufferPos));\r\n memcpy((char *)buf + bufLength, streamio->readBuffer + streamio->readBufferPos, bytesToCopy);\r\n\r\n bufLength += bytesToCopy;\r\n bytesLeftToRead -= bytesToCopy;\r\n\r\n streamio->readBufferHits += 1;\r\n streamio->readBufferPos += bytesToCopy;\r\n\r\n print_buf(opaque, stream, \"emptied [copied %d remaining %d buf %d:%d pos %lld]\\n\", bytesToCopy, bytesLeftToRead, streamio->readBufferPos, streamio->readBufferLength, streamio->position);\r\n }\r\n }\r\n\r\n return size - bytesLeftToRead;\r\n}\r\n\r\nuLong ZCALLBACK fwrite_buf_func (opaque, stream, buf, size)\r\n voidpf opaque;\r\n voidpf stream;\r\n const void* buf;\r\n uLong size;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n uInt bytesToWrite = size;\r\n uInt bytesLeftToWrite = size;\r\n uInt bytesToCopy = 0;\r\n int retVal = 0;\r\n\r\n print_buf(opaque, stream, \"write [size %ld len %d pos %lld]\\n\", size, streamio->writeBufferLength, streamio->position);\r\n\r\n if (streamio->readBufferLength > 0)\r\n {\r\n streamio->position -= streamio->readBufferLength;\r\n streamio->position += streamio->readBufferPos;\r\n\r\n streamio->readBufferLength = 0;\r\n streamio->readBufferPos = 0;\r\n\r\n print_buf(opaque, stream, \"switch from read to write [%lld]\\n\", streamio->position);\r\n\r\n if (bufio->filefunc64.zseek64_file != NULL)\r\n retVal = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, streamio->position, ZLIB_FILEFUNC_SEEK_SET);\r\n else\r\n retVal = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, (uLong)streamio->position, ZLIB_FILEFUNC_SEEK_SET);\r\n\r\n if (retVal != 0)\r\n return -1;\r\n }\r\n\r\n while (bytesLeftToWrite > 0)\r\n {\r\n bytesToCopy = min(bytesLeftToWrite, (IOBUF_BUFFERSIZE - min(streamio->writeBufferLength, streamio->writeBufferPos)));\r\n\r\n if (bytesToCopy == 0)\r\n {\r\n if (fflush_buf(opaque, stream) <= 0)\r\n return 0;\r\n\r\n continue;\r\n }\r\n \r\n memcpy(streamio->writeBuffer + streamio->writeBufferPos, (char *)buf + (bytesToWrite - bytesLeftToWrite), bytesToCopy);\r\n\r\n print_buf(opaque, stream, \"write copy [remaining %d write %d:%d len %d]\\n\", bytesToCopy, bytesToWrite, bytesLeftToWrite, streamio->writeBufferLength);\r\n\r\n bytesLeftToWrite -= bytesToCopy;\r\n\r\n streamio->writeBufferPos += bytesToCopy;\r\n streamio->writeBufferHits += 1;\r\n if (streamio->writeBufferPos > streamio->writeBufferLength)\r\n streamio->writeBufferLength += streamio->writeBufferPos - streamio->writeBufferLength;\r\n }\r\n\r\n return size - bytesLeftToWrite;\r\n}\r\n\r\nZPOS64_T ftell_buf_internal_func (opaque, stream, position)\r\n voidpf opaque;\r\n voidpf stream;\r\n ZPOS64_T position;\r\n{\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n streamio->position = position;\r\n print_buf(opaque, stream, \"tell [pos %llu readpos %d writepos %d err %d]\\n\", streamio->position, streamio->readBufferPos, streamio->writeBufferPos, errno);\r\n if (streamio->readBufferLength > 0)\r\n position -= (streamio->readBufferLength - streamio->readBufferPos);\r\n if (streamio->writeBufferLength > 0)\r\n position += streamio->writeBufferPos;\r\n return position;\r\n}\r\n\r\nlong ZCALLBACK ftell_buf_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n ZPOS64_T position = bufio->filefunc.ztell_file(bufio->filefunc.opaque, streamio->stream);\r\n return (long)ftell_buf_internal_func(opaque, stream, position);\r\n}\r\n\r\nZPOS64_T ZCALLBACK ftell64_buf_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n ZPOS64_T position = bufio->filefunc64.ztell64_file(bufio->filefunc64.opaque, streamio->stream);\r\n return ftell_buf_internal_func(opaque, stream, position);\r\n}\r\n\r\nint fseek_buf_internal_func (opaque, stream, offset, origin)\r\n voidpf opaque;\r\n voidpf stream;\r\n ZPOS64_T offset;\r\n int origin;\r\n{\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n\r\n print_buf(opaque, stream, \"seek [origin %d offset %llu pos %lld]\\n\", origin, offset, streamio->position);\r\n\r\n switch (origin)\r\n {\r\n case ZLIB_FILEFUNC_SEEK_SET:\r\n\r\n if (streamio->writeBufferLength > 0)\r\n {\r\n if ((offset >= streamio->position) && (offset <= streamio->position + streamio->writeBufferLength))\r\n {\r\n streamio->writeBufferPos = (uLong)(offset - streamio->position);\r\n return 0;\r\n }\r\n }\r\n if ((streamio->readBufferLength > 0) && (offset < streamio->position) && (offset >= streamio->position - streamio->readBufferLength))\r\n {\r\n streamio->readBufferPos = (uLong)(offset - (streamio->position - streamio->readBufferLength));\r\n return 0;\r\n }\r\n if (fflush_buf(opaque, stream) < 0)\r\n return -1;\r\n streamio->position = offset;\r\n break;\r\n\r\n case ZLIB_FILEFUNC_SEEK_CUR:\r\n\r\n if (streamio->readBufferLength > 0)\r\n {\r\n if (offset <= (streamio->readBufferLength - streamio->readBufferPos))\r\n {\r\n streamio->readBufferPos += (uLong)offset;\r\n return 0;\r\n } \r\n offset -= (streamio->readBufferLength - streamio->readBufferPos);\r\n streamio->position += offset;\r\n }\r\n if (streamio->writeBufferLength > 0)\r\n {\r\n if (offset <= (streamio->writeBufferLength - streamio->writeBufferPos))\r\n {\r\n streamio->writeBufferPos += (uLong)offset;\r\n return 0;\r\n }\r\n offset -= (streamio->writeBufferLength - streamio->writeBufferPos);\r\n }\r\n\r\n if (fflush_buf(opaque, stream) < 0)\r\n return -1;\r\n\r\n break;\r\n\r\n case ZLIB_FILEFUNC_SEEK_END:\r\n\r\n if (streamio->writeBufferLength > 0)\r\n {\r\n streamio->writeBufferPos = streamio->writeBufferLength;\r\n return 0;\r\n }\r\n break;\r\n }\r\n\r\n streamio->readBufferLength = 0;\r\n streamio->readBufferPos = 0;\r\n streamio->writeBufferLength = 0;\r\n streamio->writeBufferPos = 0;\r\n return 1;\r\n}\r\n\r\nlong ZCALLBACK fseek_buf_func (opaque, stream, offset, origin)\r\n voidpf opaque;\r\n voidpf stream;\r\n uLong offset;\r\n int origin;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n int retVal = -1;\r\n if (bufio->filefunc.zseek_file == NULL)\r\n return retVal;\r\n retVal = fseek_buf_internal_func(opaque, stream, offset, origin);\r\n if (retVal == 1)\r\n retVal = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, offset, origin);\r\n return retVal;\r\n}\r\n\r\nlong ZCALLBACK fseek64_buf_func (opaque, stream, offset, origin)\r\n voidpf opaque;\r\n voidpf stream;\r\n ZPOS64_T offset;\r\n int origin;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n int retVal = -1;\r\n if (bufio->filefunc64.zseek64_file == NULL)\r\n return retVal;\r\n retVal = fseek_buf_internal_func(opaque, stream, offset, origin);\r\n if (retVal == 1)\r\n retVal = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, offset, origin);\r\n return retVal;\r\n}\r\n\r\nint ZCALLBACK fclose_buf_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n int retVal = 0;\r\n fflush_buf(opaque, stream);\r\n print_buf(opaque, stream, \"close\\n\");\r\n if (streamio->readBufferHits + streamio->readBufferMisses > 0)\r\n print_buf(opaque, stream, \"read efficency %.02f%%\\n\", (streamio->readBufferHits / ((float)streamio->readBufferHits + streamio->readBufferMisses)) * 100);\r\n if (streamio->writeBufferHits + streamio->writeBufferMisses > 0)\r\n print_buf(opaque, stream, \"write efficency %.02f%%\\n\", (streamio->writeBufferHits / ((float)streamio->writeBufferHits + streamio->writeBufferMisses)) * 100);\r\n if (bufio->filefunc64.zclose_file != NULL)\r\n retVal = bufio->filefunc64.zclose_file(bufio->filefunc64.opaque, streamio->stream);\r\n else \r\n retVal = bufio->filefunc.zclose_file(bufio->filefunc.opaque, streamio->stream);\r\n free(streamio);\r\n return retVal;\r\n}\r\n\r\nint ZCALLBACK ferror_buf_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourbuffer_t *bufio = (ourbuffer_t *)opaque;\r\n ourstream_t *streamio = (ourstream_t *)stream;\r\n if (bufio->filefunc64.zerror_file != NULL)\r\n return bufio->filefunc64.zerror_file(bufio->filefunc64.opaque, streamio->stream);\r\n return bufio->filefunc.zerror_file(bufio->filefunc.opaque, streamio->stream);\r\n}\r\n\r\n\r\nvoid fill_buffer_filefunc (pzlib_filefunc_def, ourbuf)\r\n zlib_filefunc_def* pzlib_filefunc_def;\r\n ourbuffer_t *ourbuf;\r\n{\r\n pzlib_filefunc_def->zopen_file = fopen_buf_func;\r\n pzlib_filefunc_def->zopendisk_file = fopendisk_buf_func;\r\n pzlib_filefunc_def->zread_file = fread_buf_func;\r\n pzlib_filefunc_def->zwrite_file = fwrite_buf_func;\r\n pzlib_filefunc_def->ztell_file = ftell_buf_func;\r\n pzlib_filefunc_def->zseek_file = fseek_buf_func;\r\n pzlib_filefunc_def->zclose_file = fclose_buf_func;\r\n pzlib_filefunc_def->zerror_file = ferror_buf_func;\r\n pzlib_filefunc_def->opaque = ourbuf;\r\n}\r\n\r\nvoid fill_buffer_filefunc64 (pzlib_filefunc_def, ourbuf)\r\n zlib_filefunc64_def* pzlib_filefunc_def;\r\n ourbuffer_t *ourbuf;\r\n{\r\n pzlib_filefunc_def->zopen64_file = fopen64_buf_func;\r\n pzlib_filefunc_def->zopendisk64_file = fopendisk64_buf_func;\r\n pzlib_filefunc_def->zread_file = fread_buf_func;\r\n pzlib_filefunc_def->zwrite_file = fwrite_buf_func;\r\n pzlib_filefunc_def->ztell64_file = ftell64_buf_func;\r\n pzlib_filefunc_def->zseek64_file = fseek64_buf_func;\r\n pzlib_filefunc_def->zclose_file = fclose_buf_func;\r\n pzlib_filefunc_def->zerror_file = ferror_buf_func;\r\n pzlib_filefunc_def->opaque = ourbuf;\r\n}\r\n"
},
{
"path": "libs/minizip/source/ioapi_mem.c",
"content": "/* ioapi_mem.h -- IO base function header for compress/uncompress .zip\r\n files using zlib + zip or unzip API\r\n\r\n This version of ioapi is designed to access memory rather than files.\r\n We do use a region of memory to put data in to and take it out of. We do\r\n not have auto-extending buffers and do not inform anyone else that the\r\n data has been written. It is really intended for accessing a zip archive\r\n embedded in an application such that I can write an installer with no\r\n external files. Creation of archives has not been attempted, although\r\n parts of the framework are present.\r\n\r\n Based on Unzip ioapi.c version 0.22, May 19th, 2003\r\n\r\n Copyright (C) 1998-2003 Gilles Vollant\r\n (C) 2003 Justin Fletcher\r\n\r\n This file is under the same license as the Unzip tool it is distributed\r\n with.\r\n*/\r\n\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n#include \"zlib.h\"\r\n#include \"ioapi.h\"\r\n\r\n#include \"ioapi_mem.h\"\r\n\r\n#ifndef IOMEM_BUFFERSIZE\r\n# define IOMEM_BUFFERSIZE (64 * 1024)\r\n#endif \r\n\r\nvoidpf ZCALLBACK fopen_mem_func (opaque, filename, mode)\r\n voidpf opaque;\r\n const char* filename;\r\n int mode;\r\n{\r\n ourmemory_t *mem = (ourmemory_t *)opaque;\r\n if (mem == NULL)\r\n return NULL; /* Mem structure passed in was null */\r\n \r\n if (mode & ZLIB_FILEFUNC_MODE_CREATE)\r\n {\r\n if (mem->grow)\r\n {\r\n mem->size = IOMEM_BUFFERSIZE;\r\n mem->base = (char *)malloc(mem->size);\r\n }\r\n\r\n mem->limit = 0; /* When writing we start with 0 bytes written */\r\n }\r\n else\r\n mem->limit = mem->size;\r\n\r\n mem->cur_offset = 0;\r\n\r\n return mem;\r\n}\r\n\r\nvoidpf ZCALLBACK fopendisk_mem_func (opaque, stream, number_disk, mode)\r\n voidpf opaque;\r\n voidpf stream;\r\n int number_disk;\r\n int mode;\r\n{\r\n /* Not used */\r\n return NULL;\r\n}\r\n\r\nuLong ZCALLBACK fread_mem_func (opaque, stream, buf, size)\r\n voidpf opaque;\r\n voidpf stream;\r\n void* buf;\r\n uLong size;\r\n{\r\n ourmemory_t *mem = (ourmemory_t *)stream;\r\n\r\n if (size > mem->size - mem->cur_offset)\r\n size = mem->size - mem->cur_offset;\r\n\r\n memcpy(buf, mem->base + mem->cur_offset, size);\r\n mem->cur_offset += size;\r\n\r\n return size;\r\n}\r\n\r\n\r\nuLong ZCALLBACK fwrite_mem_func (opaque, stream, buf, size)\r\n voidpf opaque;\r\n voidpf stream;\r\n const void* buf;\r\n uLong size;\r\n{\r\n ourmemory_t *mem = (ourmemory_t *)stream;\r\n char *newbase = NULL;\r\n int newmemsize = 0;\r\n\r\n if (size > mem->size - mem->cur_offset)\r\n {\r\n if (mem->grow)\r\n {\r\n newmemsize = mem->size;\r\n if (size < IOMEM_BUFFERSIZE)\r\n newmemsize += IOMEM_BUFFERSIZE;\r\n else\r\n newmemsize += size;\r\n newbase = (char *)malloc(newmemsize);\r\n memcpy(newbase, mem->base, mem->size);\r\n free(mem->base);\r\n mem->base = newbase;\r\n mem->size = newmemsize;\r\n }\r\n else\r\n size = mem->size - mem->cur_offset;\r\n }\r\n memcpy(mem->base + mem->cur_offset, buf, size);\r\n mem->cur_offset += size;\r\n if (mem->cur_offset > mem->limit)\r\n mem->limit = mem->cur_offset;\r\n\r\n return size;\r\n}\r\n\r\nlong ZCALLBACK ftell_mem_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n ourmemory_t *mem = (ourmemory_t *)stream;\r\n return mem->cur_offset;\r\n}\r\n\r\nlong ZCALLBACK fseek_mem_func (opaque, stream, offset, origin)\r\n voidpf opaque;\r\n voidpf stream;\r\n uLong offset;\r\n int origin;\r\n{\r\n ourmemory_t *mem = (ourmemory_t *)stream;\r\n uLong new_pos;\r\n switch (origin)\r\n {\r\n case ZLIB_FILEFUNC_SEEK_CUR:\r\n new_pos = mem->cur_offset + offset;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_END:\r\n new_pos = mem->limit + offset;\r\n break;\r\n case ZLIB_FILEFUNC_SEEK_SET:\r\n new_pos = offset;\r\n break;\r\n default: \r\n return -1;\r\n }\r\n\r\n if (new_pos > mem->size)\r\n return 1; /* Failed to seek that far */\r\n mem->cur_offset = new_pos;\r\n return 0;\r\n}\r\n\r\nint ZCALLBACK fclose_mem_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n /* Even with grow = 1, caller must always free() memory */\r\n return 0;\r\n}\r\n\r\nint ZCALLBACK ferror_mem_func (opaque, stream)\r\n voidpf opaque;\r\n voidpf stream;\r\n{\r\n /* We never return errors */\r\n return 0;\r\n}\r\n\r\nvoid fill_memory_filefunc (pzlib_filefunc_def, ourmem)\r\n zlib_filefunc_def* pzlib_filefunc_def;\r\n ourmemory_t *ourmem;\r\n{\r\n pzlib_filefunc_def->zopen_file = fopen_mem_func;\r\n pzlib_filefunc_def->zopendisk_file = fopendisk_mem_func;\r\n pzlib_filefunc_def->zread_file = fread_mem_func;\r\n pzlib_filefunc_def->zwrite_file = fwrite_mem_func;\r\n pzlib_filefunc_def->ztell_file = ftell_mem_func;\r\n pzlib_filefunc_def->zseek_file = fseek_mem_func;\r\n pzlib_filefunc_def->zclose_file = fclose_mem_func;\r\n pzlib_filefunc_def->zerror_file = ferror_mem_func;\r\n pzlib_filefunc_def->opaque = ourmem;\r\n}\r\n"
},
{
"path": "libs/minizip/source/tools.cpp",
"content": "#include \"tools.h\"\r\n#include \"defs.h\"\r\n#include <algorithm>\r\n#include <iterator>\r\n\r\n#include <CDirEntry.h>\r\n\r\n#include <cstdio>\r\n\r\n#if defined(WIN32) && !defined(CYGWIN)\r\n# include \"tps/dirent.h\"\r\n# include \"tps/dirent.c\"\r\n#else\r\n# include <sys/types.h>\r\n# include <dirent.h>\r\n# include <unistd.h>\r\n#endif /* WIN32 */\r\n\r\n\r\n\r\nnamespace zipper {\r\n\r\n /* calculate the CRC32 of a file,\r\n because to encrypt a file, we need known the CRC32 of the file before */\r\n\r\n void getFileCrc(std::istream& input_stream, std::vector<char>& buff, unsigned long& result_crc)\r\n {\r\n unsigned long calculate_crc = 0;\r\n unsigned long size_read = 0;\r\n unsigned long total_read = 0;\r\n\r\n do {\r\n input_stream.read(buff.data(), buff.size());\r\n size_read = (unsigned long)input_stream.gcount();\r\n\r\n if (size_read > 0)\r\n calculate_crc = crc32(calculate_crc, (const unsigned char*)buff.data(), size_read);\r\n\r\n total_read += size_read;\r\n\r\n } while (size_read > 0);\r\n\r\n input_stream.seekg(0);\r\n result_crc = calculate_crc;\r\n }\r\n\r\n bool isLargeFile(std::istream& input_stream)\r\n {\r\n ZPOS64_T pos = 0;\r\n input_stream.seekg(0, std::ios::end);\r\n pos = input_stream.tellg();\r\n input_stream.seekg(0);\r\n\r\n return pos >= 0xffffffff;\r\n }\r\n\r\n bool checkFileExists(const std::string& filename)\r\n {\r\n return CDirEntry::exist(filename);\r\n }\r\n\r\n bool makedir(const std::string& newdir)\r\n {\r\n return CDirEntry::createDir(newdir);\r\n }\r\n\r\n void removeFolder(const std::string& foldername)\r\n {\r\n if (!CDirEntry::remove(foldername))\r\n {\r\n std::vector<std::string> files = filesFromDirectory(foldername);\r\n std::vector<std::string>::iterator it = files.begin();\r\n for (; it != files.end(); ++it)\r\n {\r\n if (isDirectory(*it) && *it != foldername)\r\n removeFolder(*it);\r\n else\r\n std::remove(it->c_str());\r\n }\r\n CDirEntry::remove(foldername);\r\n }\r\n }\r\n\r\n bool isDirectory(const std::string& path)\r\n {\r\n return CDirEntry::isDir(path);\r\n }\r\n\r\n std::string parentDirectory(const std::string& filepath)\r\n {\r\n return CDirEntry::dirName(filepath);\r\n }\r\n\r\n std::string currentPath()\r\n {\r\n char buffer[1024];\r\n getcwd(buffer, 1024);\r\n std::string result(buffer);\r\n return result;\r\n\r\n }\r\n\r\n\r\n std::vector<std::string> filesFromDirectory(const std::string& path)\r\n {\r\n std::vector<std::string> files;\r\n DIR* dir;\r\n struct dirent* entry;\r\n\r\n dir = opendir(path.c_str());\r\n\r\n if (dir == NULL)\r\n {\r\n return files;\r\n }\r\n\r\n for (entry = readdir(dir); entry != NULL; entry = readdir(dir))\r\n {\r\n std::string filename(entry->d_name);\r\n\r\n if (filename == \".\" || filename == \"..\") continue;\r\n\r\n if (CDirEntry::isDir(path + CDirEntry::Separator + filename))\r\n {\r\n std::vector<std::string> moreFiles = filesFromDirectory(path + CDirEntry::Separator + filename);\r\n std::copy(moreFiles.begin(), moreFiles.end(), std::back_inserter(files));\r\n continue;\r\n }\r\n\r\n\r\n files.push_back(path + CDirEntry::Separator + filename);\r\n }\r\n\r\n closedir(dir);\r\n\r\n\r\n return files;\r\n }\r\n\r\n std::string fileNameFromPath(const std::string& fullPath)\r\n {\r\n return CDirEntry::fileName(fullPath);\r\n }\r\n\r\n}\r\n"
},
{
"path": "libs/minizip/source/unzip.c",
"content": "/* unzip.c -- IO for uncompress .zip files using zlib\r\n Version 1.1, February 14h, 2010\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications of Unzip for Zip64\r\n Copyright (C) 2007-2008 Even Rouault\r\n Modifications for Zip64 support on both zip and unzip\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n Modifications for AES, PKWARE disk spanning\r\n Copyright (C) 2010-2014 Nathan Moinvaziri\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\n/*#ifndef NOUNCRYPT\r\n# define NOUNCRYPT\r\n#endif*/\r\n\r\n#include \"zlib.h\"\r\n#include \"unzip.h\"\r\n\r\n#ifdef STDC\r\n# include <stddef.h>\r\n# include <string.h>\r\n# include <stdlib.h>\r\n#endif\r\n#ifdef NO_ERRNO_H\r\n extern int errno;\r\n#else\r\n# include <errno.h>\r\n#endif\r\n\r\n#ifdef HAVE_AES\r\n# define AES_METHOD (99)\r\n# define AES_PWVERIFYSIZE (2)\r\n# define AES_MAXSALTLENGTH (16)\r\n# define AES_AUTHCODESIZE (10)\r\n# define AES_HEADERSIZE (11)\r\n# define AES_KEYSIZE(mode) (64 + (mode * 64))\r\n\r\n# include \"aes/aes.h\"\r\n# include \"aes/fileenc.h\"\r\n#endif\r\n#ifndef NOUNCRYPT\r\n# include \"crypt.h\"\r\n#endif\r\n\r\n#ifndef local\r\n# define local static\r\n#endif\r\n/* compile with -Dlocal if your debugger can't find static symbols */\r\n\r\n#define DISKHEADERMAGIC (0x08074b50)\r\n#define LOCALHEADERMAGIC (0x04034b50)\r\n#define CENTRALHEADERMAGIC (0x02014b50)\r\n#define ENDHEADERMAGIC (0x06054b50)\r\n#define ZIP64ENDHEADERMAGIC (0x06064b50)\r\n#define ZIP64ENDLOCHEADERMAGIC (0x07064b50)\r\n\r\n#define SIZECENTRALDIRITEM (0x2e)\r\n#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */\r\n#define SIZEZIPLOCALHEADER (0x1e)\r\n\r\n#ifndef BUFREADCOMMENT\r\n# define BUFREADCOMMENT (0x400)\r\n#endif\r\n\r\n#ifndef UNZ_BUFSIZE\r\n# define UNZ_BUFSIZE (64 * 1024)\r\n#endif\r\n#ifndef UNZ_MAXFILENAMEINZIP\r\n# define UNZ_MAXFILENAMEINZIP (256)\r\n#endif\r\n\r\n#ifndef ALLOC\r\n# define ALLOC(size) (malloc(size))\r\n#endif\r\n#ifndef TRYFREE\r\n# define TRYFREE(p) {if (p) free(p);}\r\n#endif\r\n\r\nconst char unz_copyright[] =\r\n \" unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll\";\r\n\r\n/* unz_file_info_interntal contain internal info about a file in zipfile*/\r\ntypedef struct unz_file_info64_internal_s\r\n{\r\n ZPOS64_T offset_curfile; /* relative offset of local header 8 bytes */\r\n ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */\r\n#ifdef HAVE_AES\r\n uLong aes_encryption_mode;\r\n uLong aes_compression_method;\r\n uLong aes_version;\r\n#endif\r\n} unz_file_info64_internal;\r\n\r\n/* file_in_zip_read_info_s contain internal information about a file in zipfile */\r\ntypedef struct\r\n{\r\n Bytef *read_buffer; /* internal buffer for compressed data */\r\n z_stream stream; /* zLib stream structure for inflate */\r\n\r\n#ifdef HAVE_BZIP2\r\n bz_stream bstream; /* bzLib stream structure for bziped */\r\n#endif\r\n#ifdef HAVE_AES\r\n fcrypt_ctx aes_ctx;\r\n#endif\r\n\r\n ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek */\r\n uLong stream_initialised; /* flag set if stream structure is initialised */\r\n\r\n ZPOS64_T offset_local_extrafield; /* offset of the local extra field */\r\n uInt size_local_extrafield; /* size of the local extra field */\r\n ZPOS64_T pos_local_extrafield; /* position in the local extra field in read */\r\n ZPOS64_T total_out_64;\r\n\r\n uLong crc32; /* crc32 of all data uncompressed */\r\n uLong crc32_wait; /* crc32 we must obtain after decompress all */\r\n ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */\r\n ZPOS64_T rest_read_uncompressed; /* number of byte to be obtained after decomp */\r\n\r\n zlib_filefunc64_32_def z_filefunc;\r\n\r\n voidpf filestream; /* io structore of the zipfile */\r\n uLong compression_method; /* compression method (0==store) */\r\n ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */\r\n int raw;\r\n} file_in_zip64_read_info_s;\r\n\r\n/* unz64_s contain internal information about the zipfile */\r\ntypedef struct\r\n{\r\n zlib_filefunc64_32_def z_filefunc;\r\n voidpf filestream; /* io structure of the current zipfile */\r\n voidpf filestream_with_CD; /* io structure of the disk with the central directory */\r\n unz_global_info64 gi; /* public global information */\r\n ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx)*/\r\n ZPOS64_T num_file; /* number of the current file in the zipfile*/\r\n ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/\r\n ZPOS64_T current_file_ok; /* flag about the usability of the current file*/\r\n ZPOS64_T central_pos; /* position of the beginning of the central dir*/\r\n uLong number_disk; /* number of the current disk, used for spanning ZIP*/\r\n ZPOS64_T size_central_dir; /* size of the central directory */\r\n ZPOS64_T offset_central_dir; /* offset of start of central directory with\r\n respect to the starting disk number */\r\n\r\n unz_file_info64 cur_file_info; /* public info about the current file in zip*/\r\n unz_file_info64_internal cur_file_info_internal;\r\n /* private info about it*/\r\n file_in_zip64_read_info_s* pfile_in_zip_read;\r\n /* structure about the current file if we are decompressing it */\r\n int isZip64; /* is the current file zip64 */\r\n#ifndef NOUNCRYPT\r\n unsigned long keys[3]; /* keys defining the pseudo-random sequence */\r\n const unsigned long* pcrc_32_tab;\r\n#endif\r\n} unz64_s;\r\n\r\n/* Translate date/time from Dos format to tm_unz (readable more easily) */\r\nlocal void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)\r\n{\r\n ZPOS64_T uDate = (ZPOS64_T)(ulDosDate>>16);\r\n\r\n ptm->tm_mday = (uInt)(uDate&0x1f);\r\n ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1);\r\n ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980);\r\n ptm->tm_hour = (uInt)((ulDosDate &0xF800)/0x800);\r\n ptm->tm_min = (uInt)((ulDosDate&0x7E0)/0x20);\r\n ptm->tm_sec = (uInt)(2*(ulDosDate&0x1f));\r\n\r\n#define unz64local_in_range(min, max, value) ((min) <= (value) && (value) <= (max))\r\n if (!unz64local_in_range(0, 11, ptm->tm_mon) ||\r\n !unz64local_in_range(1, 31, ptm->tm_mday) ||\r\n !unz64local_in_range(0, 23, ptm->tm_hour) ||\r\n !unz64local_in_range(0, 59, ptm->tm_min) ||\r\n !unz64local_in_range(0, 59, ptm->tm_sec))\r\n /* Invalid date stored, so don't return it. */\r\n memset(ptm, 0, sizeof(tm_unz));\r\n#undef unz64local_in_range\r\n}\r\n\r\n/* Read a byte from a gz_stream; Return EOF for end of file. */\r\nlocal int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)\r\n{\r\n unsigned char c;\r\n int err = (int)ZREAD64(*pzlib_filefunc_def, filestream, &c, 1);\r\n if (err == 1)\r\n {\r\n *pi = (int)c;\r\n return UNZ_OK;\r\n }\r\n if (ZERROR64(*pzlib_filefunc_def, filestream))\r\n return UNZ_ERRNO;\r\n return UNZ_EOF;\r\n}\r\n\r\nlocal int unz64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));\r\nlocal int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)\r\n{\r\n uLong x;\r\n int i = 0;\r\n int err;\r\n\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (uLong)i;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((uLong)i)<<8;\r\n\r\n if (err == UNZ_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n return err;\r\n}\r\n\r\nlocal int unz64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));\r\nlocal int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX)\r\n{\r\n uLong x;\r\n int i = 0;\r\n int err;\r\n\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (uLong)i;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((uLong)i)<<8;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((uLong)i)<<16;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((uLong)i)<<24;\r\n\r\n if (err == UNZ_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n return err;\r\n}\r\n\r\nlocal int unz64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));\r\nlocal int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)\r\n{\r\n ZPOS64_T x;\r\n int i = 0;\r\n int err;\r\n\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (ZPOS64_T)i;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<8;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<16;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<24;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<32;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<40;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<48;\r\n if (err == UNZ_OK)\r\n err = unz64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x |= ((ZPOS64_T)i)<<56;\r\n\r\n if (err == UNZ_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n return err;\r\n}\r\n\r\n/* Locate the Central directory of a zip file (at the end, just before the global comment) */\r\nlocal ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));\r\nlocal ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)\r\n{\r\n unsigned char* buf;\r\n ZPOS64_T file_size;\r\n ZPOS64_T back_read = 4;\r\n ZPOS64_T max_back = 0xffff; /* maximum size of global comment */\r\n ZPOS64_T pos_found = 0;\r\n uLong read_size;\r\n ZPOS64_T read_pos;\r\n int i;\r\n\r\n buf = (unsigned char*)ALLOC(BUFREADCOMMENT + 4);\r\n if (buf == NULL)\r\n return 0;\r\n\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0)\r\n {\r\n TRYFREE(buf);\r\n return 0;\r\n }\r\n\r\n file_size = ZTELL64(*pzlib_filefunc_def, filestream);\r\n\r\n if (max_back > file_size)\r\n max_back = file_size;\r\n\r\n while (back_read < max_back)\r\n {\r\n if (back_read + BUFREADCOMMENT > max_back)\r\n back_read = max_back;\r\n else\r\n back_read += BUFREADCOMMENT;\r\n\r\n read_pos = file_size - back_read;\r\n read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ?\r\n (BUFREADCOMMENT + 4) : (uLong)(file_size - read_pos);\r\n\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n break;\r\n if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size)\r\n break;\r\n\r\n for (i = (int)read_size-3; (i--) > 0;)\r\n if (((*(buf+i)) == (ENDHEADERMAGIC & 0xff)) &&\r\n ((*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff)) &&\r\n ((*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff)) &&\r\n ((*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff)))\r\n {\r\n pos_found = read_pos+i;\r\n break;\r\n }\r\n\r\n if (pos_found != 0)\r\n break;\r\n }\r\n TRYFREE(buf);\r\n return pos_found;\r\n}\r\n\r\n/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */\r\nlocal ZPOS64_T unz64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n const ZPOS64_T endcentraloffset));\r\nlocal ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n const ZPOS64_T endcentraloffset)\r\n{\r\n ZPOS64_T offset;\r\n uLong uL;\r\n\r\n /* Zip64 end of central directory locator */\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return 0;\r\n\r\n /* read locator signature */\r\n if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK)\r\n return 0;\r\n if (uL != ZIP64ENDLOCHEADERMAGIC)\r\n return 0;\r\n /* number of the disk with the start of the zip64 end of central directory */\r\n if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK)\r\n return 0;\r\n /* relative offset of the zip64 end of central directory record */\r\n if (unz64local_getLong64(pzlib_filefunc_def, filestream, &offset) != UNZ_OK)\r\n return 0;\r\n /* total number of disks */\r\n if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK)\r\n return 0;\r\n /* Goto end of central directory record */\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return 0;\r\n /* the signature */\r\n if (unz64local_getLong(pzlib_filefunc_def, filestream, &uL) != UNZ_OK)\r\n return 0;\r\n if (uL != ZIP64ENDHEADERMAGIC)\r\n return 0;\r\n\r\n return offset;\r\n}\r\n\r\nlocal unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)\r\n{\r\n unz64_s us;\r\n unz64_s *s;\r\n ZPOS64_T central_pos;\r\n uLong uL;\r\n voidpf filestream = NULL;\r\n ZPOS64_T number_entry_CD;\r\n int err = UNZ_OK;\r\n\r\n if (unz_copyright[0]!=' ')\r\n return NULL;\r\n\r\n us.filestream = NULL;\r\n us.filestream_with_CD = NULL;\r\n us.z_filefunc.zseek32_file = NULL;\r\n us.z_filefunc.ztell32_file = NULL;\r\n if (pzlib_filefunc64_32_def == NULL)\r\n fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);\r\n else\r\n us.z_filefunc = *pzlib_filefunc64_32_def;\r\n\r\n us.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\r\n\r\n if (us.filestream == NULL)\r\n return NULL;\r\n\r\n us.filestream_with_CD = us.filestream;\r\n us.isZip64 = 0;\r\n\r\n /* Use unz64local_SearchCentralDir first. Only based on the result\r\n is it necessary to locate the unz64local_SearchCentralDir64 */\r\n central_pos = unz64local_SearchCentralDir(&us.z_filefunc, us.filestream);\r\n if (central_pos)\r\n {\r\n if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = UNZ_ERRNO;\r\n\r\n /* the signature, already checked */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* number of this disk */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n us.number_disk = uL;\r\n /* number of the disk with the start of the central directory */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream,& uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n us.gi.number_disk_with_CD = uL;\r\n /* total number of entries in the central directory on this disk */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n us.gi.number_entry = uL;\r\n /* total number of entries in the central directory */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n number_entry_CD = uL;\r\n if (number_entry_CD != us.gi.number_entry)\r\n err = UNZ_BADZIPFILE;\r\n /* size of the central directory */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n us.size_central_dir = uL;\r\n /* offset of start of central directory with respect to the starting disk number */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n us.offset_central_dir = uL;\r\n /* zipfile comment length */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n\r\n if ((err == UNZ_OK) &&\r\n ((us.gi.number_entry == 0xffff) || (us.size_central_dir == 0xffff) || (us.offset_central_dir == 0xffffffff)))\r\n {\r\n /* Format should be Zip64, as the central directory or file size is too large */\r\n central_pos = unz64local_SearchCentralDir64(&us.z_filefunc, us.filestream, central_pos);\r\n if (central_pos)\r\n {\r\n ZPOS64_T uL64;\r\n\r\n us.isZip64 = 1;\r\n\r\n if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = UNZ_ERRNO;\r\n\r\n /* the signature, already checked */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* size of zip64 end of central directory record */\r\n if (unz64local_getLong64(&us.z_filefunc, us.filestream, &uL64) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* version made by */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* version needed to extract */\r\n if (unz64local_getShort(&us.z_filefunc, us.filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* number of this disk */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &us.number_disk) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* number of the disk with the start of the central directory */\r\n if (unz64local_getLong(&us.z_filefunc, us.filestream, &us.gi.number_disk_with_CD) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* total number of entries in the central directory on this disk */\r\n if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* total number of entries in the central directory */\r\n if (unz64local_getLong64(&us.z_filefunc, us.filestream, &number_entry_CD) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (number_entry_CD != us.gi.number_entry)\r\n err = UNZ_BADZIPFILE;\r\n /* size of the central directory */\r\n if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.size_central_dir) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* offset of start of central directory with respect to the starting disk number */\r\n if (unz64local_getLong64(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n }\r\n else\r\n err = UNZ_BADZIPFILE;\r\n }\r\n }\r\n else\r\n err = UNZ_ERRNO;\r\n\r\n if ((err == UNZ_OK) && (central_pos < us.offset_central_dir + us.size_central_dir))\r\n err = UNZ_BADZIPFILE;\r\n\r\n if (err != UNZ_OK)\r\n {\r\n ZCLOSE64(us.z_filefunc, us.filestream);\r\n return NULL;\r\n }\r\n\r\n if (us.gi.number_disk_with_CD == 0)\r\n {\r\n /* If there is only one disk open another stream so we don't have to seek between the CD\r\n and the file headers constantly */\r\n filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\r\n if (filestream != NULL)\r\n us.filestream = filestream;\r\n }\r\n\r\n /* Hack for zip files that have no respect for zip64\r\n if ((central_pos > 0xffffffff) && (us.offset_central_dir < 0xffffffff))\r\n us.offset_central_dir = central_pos - us.size_central_dir;*/\r\n\r\n us.byte_before_the_zipfile = central_pos - (us.offset_central_dir + us.size_central_dir);\r\n us.central_pos = central_pos;\r\n us.pfile_in_zip_read = NULL;\r\n\r\n s = (unz64_s*)ALLOC(sizeof(unz64_s));\r\n if (s != NULL)\r\n {\r\n *s = us;\r\n unzGoToFirstFile((unzFile)s);\r\n }\r\n return (unzFile)s;\r\n}\r\n\r\nextern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def* pzlib_filefunc32_def)\r\n{\r\n if (pzlib_filefunc32_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def);\r\n return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);\r\n }\r\n return unzOpenInternal(path, NULL);\r\n}\r\n\r\nextern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def* pzlib_filefunc_def)\r\n{\r\n if (pzlib_filefunc_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;\r\n zlib_filefunc64_32_def_fill.ztell32_file = NULL;\r\n zlib_filefunc64_32_def_fill.zseek32_file = NULL;\r\n return unzOpenInternal(path, &zlib_filefunc64_32_def_fill);\r\n }\r\n return unzOpenInternal(path, NULL);\r\n}\r\n\r\nextern unzFile ZEXPORT unzOpen(const char *path)\r\n{\r\n return unzOpenInternal(path, NULL);\r\n}\r\n\r\nextern unzFile ZEXPORT unzOpen64(const void *path)\r\n{\r\n return unzOpenInternal(path, NULL);\r\n}\r\n\r\nextern int ZEXPORT unzClose(unzFile file)\r\n{\r\n unz64_s* s;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n\r\n if (s->pfile_in_zip_read != NULL)\r\n unzCloseCurrentFile(file);\r\n\r\n if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))\r\n ZCLOSE64(s->z_filefunc, s->filestream);\r\n if (s->filestream_with_CD != NULL)\r\n ZCLOSE64(s->z_filefunc, s->filestream_with_CD);\r\n\r\n s->filestream = NULL;\r\n s->filestream_with_CD = NULL;\r\n TRYFREE(s);\r\n return UNZ_OK;\r\n}\r\n\r\n/* Goto to the next available disk for spanned archives */\r\nlocal int unzGoToNextDisk OF((unzFile file));\r\nlocal int unzGoToNextDisk(unzFile file)\r\n{\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n uLong number_disk_next = 0;\r\n\r\n s = (unz64_s*)file;\r\n if (s == NULL)\r\n return UNZ_PARAMERROR;\r\n pfile_in_zip_read_info = s->pfile_in_zip_read;\r\n number_disk_next = s->number_disk;\r\n\r\n if ((pfile_in_zip_read_info != NULL) && (pfile_in_zip_read_info->rest_read_uncompressed > 0))\r\n /* We are currently reading a file and we need the next sequential disk */\r\n number_disk_next += 1;\r\n else\r\n /* Goto the disk for the current file */\r\n number_disk_next = s->cur_file_info.disk_num_start;\r\n\r\n if (number_disk_next != s->number_disk)\r\n {\r\n /* Switch disks */\r\n if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))\r\n ZCLOSE64(s->z_filefunc, s->filestream);\r\n\r\n if (number_disk_next == s->gi.number_disk_with_CD)\r\n {\r\n s->filestream = s->filestream_with_CD;\r\n }\r\n else\r\n {\r\n s->filestream = ZOPENDISK64(s->z_filefunc, s->filestream_with_CD, number_disk_next,\r\n ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);\r\n }\r\n\r\n if (s->filestream == NULL)\r\n return UNZ_ERRNO;\r\n\r\n s->number_disk = number_disk_next;\r\n }\r\n\r\n return UNZ_OK;\r\n}\r\n\r\nextern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info* pglobal_info32)\r\n{\r\n unz64_s* s;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n /* to do : check if number_entry is not truncated */\r\n pglobal_info32->number_entry = (uLong)s->gi.number_entry;\r\n pglobal_info32->size_comment = s->gi.size_comment;\r\n pglobal_info32->number_disk_with_CD = s->gi.number_disk_with_CD;\r\n return UNZ_OK;\r\n}\r\n\r\nextern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64* pglobal_info)\r\n{\r\n unz64_s* s;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n *pglobal_info = s->gi;\r\n return UNZ_OK;\r\n}\r\n\r\nextern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uLong comment_size)\r\n{\r\n unz64_s* s;\r\n uLong bytes_to_read = comment_size;\r\n if (file == NULL)\r\n return (int)UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n\r\n if (bytes_to_read > s->gi.size_comment)\r\n bytes_to_read = s->gi.size_comment;\r\n\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return UNZ_ERRNO;\r\n\r\n if (bytes_to_read>0)\r\n {\r\n *comment = 0;\r\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, bytes_to_read) != bytes_to_read)\r\n return UNZ_ERRNO;\r\n }\r\n\r\n if ((comment != NULL) && (comment_size > s->gi.size_comment))\r\n *(comment+s->gi.size_comment) = 0;\r\n return (int)bytes_to_read;\r\n}\r\n\r\n/* Get Info about the current file in the zipfile, with internal only info */\r\nlocal int unz64local_GetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info,\r\n unz_file_info64_internal *pfile_info_internal, char *filename, uLong filename_size, void *extrafield,\r\n uLong extrafield_size, char *comment, uLong comment_size)\r\n{\r\n unz64_s* s;\r\n unz_file_info64 file_info;\r\n unz_file_info64_internal file_info_internal;\r\n ZPOS64_T bytes_to_read;\r\n int err = UNZ_OK;\r\n uLong uMagic;\r\n long lSeek = 0;\r\n ZPOS64_T current_pos = 0;\r\n uLong acc = 0;\r\n uLong uL;\r\n ZPOS64_T uL64;\r\n\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,\r\n s->pos_in_central_dir + s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = UNZ_ERRNO;\r\n\r\n /* Check the magic */\r\n if (err == UNZ_OK)\r\n {\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uMagic) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n else if (uMagic != CENTRALHEADERMAGIC)\r\n err = UNZ_BADZIPFILE;\r\n }\r\n\r\n /* Read central directory header */\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.version) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.version_needed) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.flag) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.compression_method) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.dosDate) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n unz64local_DosDateToTmuDate(file_info.dosDate, &file_info.tmu_date);\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.crc) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n file_info.compressed_size = uL;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n file_info.uncompressed_size = uL;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_filename) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_extra) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_comment) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &file_info.internal_fa) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.external_fa) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* Relative offset of local header */\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n\r\n file_info.size_file_extra_internal = 0;\r\n file_info.disk_offset = uL;\r\n file_info_internal.offset_curfile = uL;\r\n#ifdef HAVE_AES\r\n file_info_internal.aes_compression_method = 0;\r\n file_info_internal.aes_encryption_mode = 0;\r\n file_info_internal.aes_version = 0;\r\n#endif\r\n\r\n lSeek += file_info.size_filename;\r\n\r\n if ((err == UNZ_OK) && (filename != NULL))\r\n {\r\n if (file_info.size_filename < filename_size)\r\n {\r\n *(filename+file_info.size_filename) = 0;\r\n bytes_to_read = file_info.size_filename;\r\n }\r\n else\r\n bytes_to_read = filename_size;\r\n\r\n if ((file_info.size_filename > 0) && (filename_size > 0))\r\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD,filename, (uLong)bytes_to_read) != bytes_to_read)\r\n err = UNZ_ERRNO;\r\n lSeek -= (uLong)bytes_to_read;\r\n }\r\n\r\n /* Read extrafield */\r\n if ((err == UNZ_OK) && (extrafield != NULL))\r\n {\r\n if (file_info.size_file_extra < extrafield_size)\r\n bytes_to_read = file_info.size_file_extra;\r\n else\r\n bytes_to_read = extrafield_size;\r\n\r\n if (lSeek != 0)\r\n {\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0)\r\n lSeek=0;\r\n else\r\n err = UNZ_ERRNO;\r\n }\r\n\r\n if ((file_info.size_file_extra > 0) && (extrafield_size > 0))\r\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD, extrafield, (uLong)bytes_to_read) != bytes_to_read)\r\n err = UNZ_ERRNO;\r\n lSeek += file_info.size_file_extra - (uLong)bytes_to_read;\r\n }\r\n else\r\n lSeek += file_info.size_file_extra;\r\n\r\n if ((err == UNZ_OK) && (file_info.size_file_extra != 0))\r\n {\r\n if (lSeek != 0)\r\n {\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) == 0)\r\n lSeek=0;\r\n else\r\n err = UNZ_ERRNO;\r\n }\r\n\r\n /* We are going to parse the extra field so we need to move back */\r\n current_pos = ZTELL64(s->z_filefunc, s->filestream_with_CD);\r\n if (current_pos < file_info.size_file_extra)\r\n err = UNZ_ERRNO;\r\n current_pos -= file_info.size_file_extra;\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, current_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = UNZ_ERRNO;\r\n\r\n while((err != UNZ_ERRNO) && (acc < file_info.size_file_extra))\r\n {\r\n uLong headerid;\r\n uLong datasize;\r\n\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &headerid) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &datasize) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n\r\n /* ZIP64 extra fields */\r\n if (headerid == 0x0001)\r\n {\r\n /* Subtract size of ZIP64 field, since ZIP64 is handled internally */\r\n file_info.size_file_extra_internal += 2 + 2 + datasize;\r\n\r\n if (file_info.uncompressed_size == 0xffffffff)\r\n {\r\n if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n }\r\n if (file_info.compressed_size == 0xffffffff)\r\n {\r\n if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n }\r\n if (file_info_internal.offset_curfile == 0xffffffff)\r\n {\r\n /* Relative Header offset */\r\n if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &uL64) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n file_info_internal.offset_curfile = uL64;\r\n file_info.disk_offset = uL64;\r\n }\r\n if (file_info.disk_num_start == 0xffffffff)\r\n {\r\n /* Disk Start Number */\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n }\r\n }\r\n#ifdef HAVE_AES\r\n /* AES header */\r\n else if (headerid == 0x9901)\r\n {\r\n /* Subtract size of AES field, since AES is handled internally */\r\n file_info.size_file_extra_internal += 2 + 2 + datasize;\r\n\r\n /* Verify version info */\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n /* Support AE-1 and AE-2 */\r\n if (uL != 1 && uL != 2)\r\n err = UNZ_ERRNO;\r\n file_info_internal.aes_version = uL;\r\n if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if ((char)uL != 'A')\r\n err = UNZ_ERRNO;\r\n if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if ((char)uL != 'E')\r\n err = UNZ_ERRNO;\r\n /* Get AES encryption strength and actual compression method */\r\n if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n file_info_internal.aes_encryption_mode = uL;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n file_info_internal.aes_compression_method = uL;\r\n }\r\n#endif\r\n else\r\n {\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,datasize, ZLIB_FILEFUNC_SEEK_CUR) != 0)\r\n err = UNZ_ERRNO;\r\n }\r\n\r\n acc += 2 + 2 + datasize;\r\n }\r\n }\r\n\r\n if (file_info.disk_num_start == s->gi.number_disk_with_CD)\r\n file_info_internal.byte_before_the_zipfile = s->byte_before_the_zipfile;\r\n else\r\n file_info_internal.byte_before_the_zipfile = 0;\r\n\r\n if ((err == UNZ_OK) && (comment != NULL))\r\n {\r\n if (file_info.size_file_comment < comment_size)\r\n {\r\n *(comment+file_info.size_file_comment) = 0;\r\n bytes_to_read = file_info.size_file_comment;\r\n }\r\n else\r\n bytes_to_read = comment_size;\r\n\r\n if (lSeek != 0)\r\n {\r\n if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, lSeek, ZLIB_FILEFUNC_SEEK_CUR) != 0)\r\n err = UNZ_ERRNO;\r\n }\r\n\r\n if ((file_info.size_file_comment > 0) && (comment_size > 0))\r\n if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, (uLong)bytes_to_read) != bytes_to_read)\r\n err = UNZ_ERRNO;\r\n lSeek += file_info.size_file_comment - (uLong)bytes_to_read;\r\n }\r\n else\r\n lSeek += file_info.size_file_comment;\r\n\r\n if ((err == UNZ_OK) && (pfile_info != NULL))\r\n *pfile_info = file_info;\r\n\r\n if ((err == UNZ_OK) && (pfile_info_internal != NULL))\r\n *pfile_info_internal = file_info_internal;\r\n\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info * pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char* comment, uLong comment_size)\r\n{\r\n unz_file_info64 file_info64;\r\n int err;\r\n\r\n err = unz64local_GetCurrentFileInfoInternal(file, &file_info64, NULL, filename, filename_size,\r\n extrafield, extrafield_size, comment, comment_size);\r\n\r\n if ((err == UNZ_OK) && (pfile_info != NULL))\r\n {\r\n pfile_info->version = file_info64.version;\r\n pfile_info->version_needed = file_info64.version_needed;\r\n pfile_info->flag = file_info64.flag;\r\n pfile_info->compression_method = file_info64.compression_method;\r\n pfile_info->dosDate = file_info64.dosDate;\r\n pfile_info->crc = file_info64.crc;\r\n\r\n pfile_info->size_filename = file_info64.size_filename;\r\n pfile_info->size_file_extra = file_info64.size_file_extra - file_info64.size_file_extra_internal;\r\n pfile_info->size_file_comment = file_info64.size_file_comment;\r\n\r\n pfile_info->disk_num_start = file_info64.disk_num_start;\r\n pfile_info->internal_fa = file_info64.internal_fa;\r\n pfile_info->external_fa = file_info64.external_fa;\r\n\r\n pfile_info->tmu_date = file_info64.tmu_date,\r\n\r\n pfile_info->compressed_size = (uLong)file_info64.compressed_size;\r\n pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;\r\n\r\n }\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char* comment, uLong comment_size)\r\n{\r\n return unz64local_GetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size,\r\n extrafield, extrafield_size, comment,comment_size);\r\n}\r\n\r\n/* Read the local header of the current zipfile. Check the coherency of the local header and info in the\r\n end of central directory about this file store in *piSizeVar the size of extra info in local header\r\n (filename and size of extra field data) */\r\nlocal int unz64local_CheckCurrentFileCoherencyHeader(unz64_s* s, uInt* piSizeVar, ZPOS64_T *poffset_local_extrafield,\r\n uInt *psize_local_extrafield)\r\n{\r\n uLong uMagic, uL, uFlags;\r\n uLong size_filename;\r\n uLong size_extra_field;\r\n int err = UNZ_OK;\r\n int compression_method = 0;\r\n\r\n *piSizeVar = 0;\r\n *poffset_local_extrafield = 0;\r\n *psize_local_extrafield = 0;\r\n\r\n err = unzGoToNextDisk((unzFile)s);\r\n if (err != UNZ_OK)\r\n return err;\r\n\r\n if (ZSEEK64(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile +\r\n s->cur_file_info_internal.byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return UNZ_ERRNO;\r\n\r\n if (err == UNZ_OK)\r\n {\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream, &uMagic) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n else if (uMagic != LOCALHEADERMAGIC)\r\n err = UNZ_BADZIPFILE;\r\n }\r\n\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream, &uFlags) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream, &uL) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n else if ((err == UNZ_OK) && (uL != s->cur_file_info.compression_method))\r\n err = UNZ_BADZIPFILE;\r\n\r\n compression_method = (int)s->cur_file_info.compression_method;\r\n#ifdef HAVE_AES\r\n if (compression_method == AES_METHOD)\r\n compression_method = (int)s->cur_file_info_internal.aes_compression_method;\r\n#endif\r\n\r\n if ((err == UNZ_OK) && (compression_method != 0) &&\r\n#ifdef HAVE_BZIP2\r\n (compression_method != Z_BZIP2ED) &&\r\n#endif\r\n (compression_method != Z_DEFLATED))\r\n err = UNZ_BADZIPFILE;\r\n\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* date/time */\r\n err = UNZ_ERRNO;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* crc */\r\n err = UNZ_ERRNO;\r\n else if ((err == UNZ_OK) && (uL != s->cur_file_info.crc) && ((uFlags & 8) == 0))\r\n err = UNZ_BADZIPFILE;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* size compr */\r\n err = UNZ_ERRNO;\r\n else if ((uL != 0xffffffff) && (err == UNZ_OK) && (uL != s->cur_file_info.compressed_size) && ((uFlags & 8) == 0))\r\n err = UNZ_BADZIPFILE;\r\n if (unz64local_getLong(&s->z_filefunc, s->filestream, &uL) != UNZ_OK) /* size uncompr */\r\n err = UNZ_ERRNO;\r\n else if ((uL != 0xffffffff) && (err == UNZ_OK) && (uL != s->cur_file_info.uncompressed_size) && ((uFlags & 8) == 0))\r\n err = UNZ_BADZIPFILE;\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n else if ((err == UNZ_OK) && (size_filename != s->cur_file_info.size_filename))\r\n err = UNZ_BADZIPFILE;\r\n\r\n *piSizeVar += (uInt)size_filename;\r\n\r\n if (unz64local_getShort(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK)\r\n err = UNZ_ERRNO;\r\n *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_filename;\r\n *psize_local_extrafield = (uInt)size_extra_field;\r\n\r\n *piSizeVar += (uInt)size_extra_field;\r\n\r\n return err;\r\n}\r\n\r\n/*\r\n Open for reading data the current file in the zipfile.\r\n If there is no error and the file is opened, the return value is UNZ_OK.\r\n*/\r\nextern int ZEXPORT unzOpenCurrentFile3(unzFile file, int* method, int* level, int raw, const char* password)\r\n{\r\n int err = UNZ_OK;\r\n int compression_method;\r\n uInt iSizeVar;\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n ZPOS64_T offset_local_extrafield;\r\n uInt size_local_extrafield;\r\n#ifndef NOUNCRYPT\r\n char source[12];\r\n#else\r\n if (password != NULL)\r\n return UNZ_PARAMERROR;\r\n#endif\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n if (!s->current_file_ok)\r\n return UNZ_PARAMERROR;\r\n\r\n if (s->pfile_in_zip_read != NULL)\r\n unzCloseCurrentFile(file);\r\n\r\n if (unz64local_CheckCurrentFileCoherencyHeader(s, &iSizeVar, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK)\r\n return UNZ_BADZIPFILE;\r\n\r\n pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_INTERNALERROR;\r\n\r\n pfile_in_zip_read_info->read_buffer = (Bytef*)ALLOC(UNZ_BUFSIZE);\r\n pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;\r\n pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;\r\n pfile_in_zip_read_info->pos_local_extrafield = 0;\r\n pfile_in_zip_read_info->raw = raw;\r\n\r\n if (pfile_in_zip_read_info->read_buffer == NULL)\r\n {\r\n TRYFREE(pfile_in_zip_read_info);\r\n return UNZ_INTERNALERROR;\r\n }\r\n\r\n pfile_in_zip_read_info->stream_initialised = 0;\r\n\r\n compression_method = (int)s->cur_file_info.compression_method;\r\n#ifdef HAVE_AES\r\n if (compression_method == AES_METHOD)\r\n compression_method = (int)s->cur_file_info_internal.aes_compression_method;\r\n#endif\r\n\r\n if (method != NULL)\r\n *method = compression_method;\r\n\r\n if (level != NULL)\r\n {\r\n *level = 6;\r\n switch (s->cur_file_info.flag & 0x06)\r\n {\r\n case 6 : *level = 1; break;\r\n case 4 : *level = 2; break;\r\n case 2 : *level = 9; break;\r\n }\r\n }\r\n\r\n if ((compression_method != 0) &&\r\n#ifdef HAVE_BZIP2\r\n (compression_method != Z_BZIP2ED) &&\r\n#endif\r\n (compression_method != Z_DEFLATED))\r\n err = UNZ_BADZIPFILE;\r\n\r\n pfile_in_zip_read_info->crc32_wait = s->cur_file_info.crc;\r\n pfile_in_zip_read_info->crc32 = 0;\r\n pfile_in_zip_read_info->total_out_64 = 0;\r\n pfile_in_zip_read_info->compression_method = compression_method;\r\n pfile_in_zip_read_info->filestream = s->filestream;\r\n pfile_in_zip_read_info->z_filefunc = s->z_filefunc;\r\n if (s->number_disk == s->gi.number_disk_with_CD)\r\n pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile;\r\n else\r\n pfile_in_zip_read_info->byte_before_the_zipfile = 0;\r\n pfile_in_zip_read_info->stream.total_out = 0;\r\n pfile_in_zip_read_info->stream.total_in = 0;\r\n pfile_in_zip_read_info->stream.next_in = NULL;\r\n\r\n if (!raw)\r\n {\r\n if (compression_method == Z_BZIP2ED)\r\n {\r\n#ifdef HAVE_BZIP2\r\n pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;\r\n pfile_in_zip_read_info->bstream.bzfree = (free_func)0;\r\n pfile_in_zip_read_info->bstream.opaque = (voidpf)0;\r\n pfile_in_zip_read_info->bstream.state = (voidpf)0;\r\n\r\n pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;\r\n pfile_in_zip_read_info->stream.zfree = (free_func)0;\r\n pfile_in_zip_read_info->stream.opaque = (voidpf)0;\r\n pfile_in_zip_read_info->stream.next_in = (voidpf)0;\r\n pfile_in_zip_read_info->stream.avail_in = 0;\r\n\r\n err = BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);\r\n if (err == Z_OK)\r\n pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;\r\n else\r\n {\r\n TRYFREE(pfile_in_zip_read_info);\r\n return err;\r\n }\r\n#else\r\n pfile_in_zip_read_info->raw=1;\r\n#endif\r\n }\r\n else if (compression_method == Z_DEFLATED)\r\n {\r\n pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;\r\n pfile_in_zip_read_info->stream.zfree = (free_func)0;\r\n pfile_in_zip_read_info->stream.opaque = (voidpf)s;\r\n pfile_in_zip_read_info->stream.next_in = 0;\r\n pfile_in_zip_read_info->stream.avail_in = 0;\r\n\r\n err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);\r\n if (err == Z_OK)\r\n pfile_in_zip_read_info->stream_initialised = Z_DEFLATED;\r\n else\r\n {\r\n TRYFREE(pfile_in_zip_read_info);\r\n return err;\r\n }\r\n /* windowBits is passed < 0 to tell that there is no zlib header.\r\n * Note that in this case inflate *requires* an extra \"dummy\" byte\r\n * after the compressed stream in order to complete decompression and\r\n * return Z_STREAM_END.\r\n * In unzip, i don't wait absolutely Z_STREAM_END because I known the\r\n * size of both compressed and uncompressed data\r\n */\r\n }\r\n }\r\n\r\n pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size;\r\n pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size;\r\n pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + iSizeVar;\r\n pfile_in_zip_read_info->stream.avail_in = (uInt)0;\r\n\r\n s->pfile_in_zip_read = pfile_in_zip_read_info;\r\n\r\n#ifndef NOUNCRYPT\r\n if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0))\r\n {\r\n if (ZSEEK64(s->z_filefunc, s->filestream,\r\n s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile,\r\n ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return UNZ_INTERNALERROR;\r\n#ifdef HAVE_AES\r\n if (s->cur_file_info.compression_method == AES_METHOD)\r\n {\r\n unsigned char passverify[AES_PWVERIFYSIZE];\r\n unsigned char saltvalue[AES_MAXSALTLENGTH];\r\n uInt saltlength;\r\n\r\n if ((s->cur_file_info_internal.aes_encryption_mode < 1) ||\r\n (s->cur_file_info_internal.aes_encryption_mode > 3))\r\n return UNZ_INTERNALERROR;\r\n\r\n saltlength = SALT_LENGTH(s->cur_file_info_internal.aes_encryption_mode);\r\n\r\n if (ZREAD64(s->z_filefunc, s->filestream, saltvalue, saltlength) != saltlength)\r\n return UNZ_INTERNALERROR;\r\n if (ZREAD64(s->z_filefunc, s->filestream, passverify, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE)\r\n return UNZ_INTERNALERROR;\r\n\r\n fcrypt_init(s->cur_file_info_internal.aes_encryption_mode, password, strlen(password), saltvalue,\r\n passverify, &s->pfile_in_zip_read->aes_ctx);\r\n\r\n pfile_in_zip_read_info->rest_read_compressed -= saltlength + AES_PWVERIFYSIZE;\r\n pfile_in_zip_read_info->rest_read_compressed -= AES_AUTHCODESIZE;\r\n\r\n s->pfile_in_zip_read->pos_in_zipfile += saltlength + AES_PWVERIFYSIZE;\r\n }\r\n else\r\n#endif\r\n {\r\n int i;\r\n s->pcrc_32_tab = (const unsigned long*)get_crc_table();\r\n init_keys(password, s->keys, s->pcrc_32_tab);\r\n\r\n if (ZREAD64(s->z_filefunc, s->filestream, source, 12) < 12)\r\n return UNZ_INTERNALERROR;\r\n\r\n for (i = 0; i < 12; i++)\r\n zdecode(s->keys, s->pcrc_32_tab, source[i]);\r\n\r\n pfile_in_zip_read_info->rest_read_compressed -= 12;\r\n\r\n s->pfile_in_zip_read->pos_in_zipfile += 12;\r\n }\r\n }\r\n#endif\r\n\r\n return UNZ_OK;\r\n}\r\n\r\nextern int ZEXPORT unzOpenCurrentFile(unzFile file)\r\n{\r\n return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);\r\n}\r\n\r\nextern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char* password)\r\n{\r\n return unzOpenCurrentFile3(file, NULL, NULL, 0, password);\r\n}\r\n\r\nextern int ZEXPORT unzOpenCurrentFile2(unzFile file, int* method, int* level, int raw)\r\n{\r\n return unzOpenCurrentFile3(file, method, level, raw, NULL);\r\n}\r\n\r\n/* Read bytes from the current file.\r\n buf contain buffer where data must be copied\r\n len the size of buf.\r\n\r\n return the number of byte copied if some bytes are copied\r\n return 0 if the end of file was reached\r\n return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */\r\nextern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, unsigned len)\r\n{\r\n int err = UNZ_OK;\r\n uInt read = 0;\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info = s->pfile_in_zip_read;\r\n\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_PARAMERROR;\r\n if (pfile_in_zip_read_info->read_buffer == NULL)\r\n return UNZ_END_OF_LIST_OF_FILE;\r\n if (len == 0)\r\n return 0;\r\n\r\n pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;\r\n pfile_in_zip_read_info->stream.avail_out = (uInt)len;\r\n\r\n if (pfile_in_zip_read_info->raw)\r\n {\r\n if (len > pfile_in_zip_read_info->rest_read_compressed + pfile_in_zip_read_info->stream.avail_in)\r\n pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_compressed +\r\n pfile_in_zip_read_info->stream.avail_in;\r\n }\r\n else\r\n {\r\n if (len > pfile_in_zip_read_info->rest_read_uncompressed)\r\n pfile_in_zip_read_info->stream.avail_out = (uInt)pfile_in_zip_read_info->rest_read_uncompressed;\r\n }\r\n\r\n while (pfile_in_zip_read_info->stream.avail_out>0)\r\n {\r\n if (pfile_in_zip_read_info->stream.avail_in == 0)\r\n {\r\n uInt bytes_to_read = UNZ_BUFSIZE;\r\n uInt bytes_not_read = 0;\r\n uInt bytes_read = 0;\r\n uInt total_bytes_read = 0;\r\n\r\n if (pfile_in_zip_read_info->stream.next_in != NULL)\r\n bytes_not_read = pfile_in_zip_read_info->read_buffer + UNZ_BUFSIZE -\r\n pfile_in_zip_read_info->stream.next_in;\r\n bytes_to_read -= bytes_not_read;\r\n if (bytes_not_read > 0)\r\n memcpy(pfile_in_zip_read_info->read_buffer, pfile_in_zip_read_info->stream.next_in, bytes_not_read);\r\n if (pfile_in_zip_read_info->rest_read_compressed < bytes_to_read)\r\n bytes_to_read = (uInt)pfile_in_zip_read_info->rest_read_compressed;\r\n\r\n while (total_bytes_read != bytes_to_read)\r\n {\r\n if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream,\r\n pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile,\r\n ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return UNZ_ERRNO;\r\n\r\n bytes_read = ZREAD64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream,\r\n pfile_in_zip_read_info->read_buffer + bytes_not_read + total_bytes_read,\r\n bytes_to_read - total_bytes_read);\r\n\r\n total_bytes_read += bytes_read;\r\n pfile_in_zip_read_info->pos_in_zipfile += bytes_read;\r\n\r\n if (bytes_read == 0)\r\n {\r\n if (ZERROR64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream))\r\n return UNZ_ERRNO;\r\n\r\n err = unzGoToNextDisk(file);\r\n if (err != UNZ_OK)\r\n return err;\r\n\r\n pfile_in_zip_read_info->pos_in_zipfile = 0;\r\n pfile_in_zip_read_info->filestream = s->filestream;\r\n }\r\n }\r\n\r\n#ifndef NOUNCRYPT\r\n if ((s->cur_file_info.flag & 1) != 0)\r\n {\r\n#ifdef HAVE_AES\r\n if (s->cur_file_info.compression_method == AES_METHOD)\r\n {\r\n fcrypt_decrypt(pfile_in_zip_read_info->read_buffer, bytes_to_read, &s->pfile_in_zip_read->aes_ctx);\r\n }\r\n else\r\n#endif\r\n {\r\n uInt i;\r\n for(i = 0; i < total_bytes_read; i++)\r\n pfile_in_zip_read_info->read_buffer[i] =\r\n zdecode(s->keys, s->pcrc_32_tab, pfile_in_zip_read_info->read_buffer[i]);\r\n }\r\n }\r\n#endif\r\n\r\n pfile_in_zip_read_info->rest_read_compressed -= total_bytes_read;\r\n pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->read_buffer;\r\n pfile_in_zip_read_info->stream.avail_in = (uInt)bytes_not_read + total_bytes_read;\r\n }\r\n\r\n if ((pfile_in_zip_read_info->compression_method == 0) || (pfile_in_zip_read_info->raw))\r\n {\r\n uInt copy,i;\r\n\r\n if ((pfile_in_zip_read_info->stream.avail_in == 0) &&\r\n (pfile_in_zip_read_info->rest_read_compressed == 0))\r\n return (read == 0) ? UNZ_EOF : read;\r\n\r\n if (pfile_in_zip_read_info->stream.avail_out < pfile_in_zip_read_info->stream.avail_in)\r\n copy = pfile_in_zip_read_info->stream.avail_out;\r\n else\r\n copy = pfile_in_zip_read_info->stream.avail_in;\r\n\r\n for (i = 0; i < copy; i++)\r\n *(pfile_in_zip_read_info->stream.next_out+i) =\r\n *(pfile_in_zip_read_info->stream.next_in+i);\r\n\r\n pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + copy;\r\n pfile_in_zip_read_info->rest_read_uncompressed -= copy;\r\n pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,\r\n pfile_in_zip_read_info->stream.next_out, copy);\r\n\r\n pfile_in_zip_read_info->stream.avail_in -= copy;\r\n pfile_in_zip_read_info->stream.avail_out -= copy;\r\n pfile_in_zip_read_info->stream.next_out += copy;\r\n pfile_in_zip_read_info->stream.next_in += copy;\r\n pfile_in_zip_read_info->stream.total_out += copy;\r\n read += copy;\r\n }\r\n else if (pfile_in_zip_read_info->compression_method == Z_BZIP2ED)\r\n {\r\n#ifdef HAVE_BZIP2\r\n uLong total_out_before, total_out_after;\r\n const Bytef *buf_before;\r\n uLong out_bytes;\r\n\r\n pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in;\r\n pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in;\r\n pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in;\r\n pfile_in_zip_read_info->bstream.total_in_hi32 = 0;\r\n pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out;\r\n pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out;\r\n pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;\r\n pfile_in_zip_read_info->bstream.total_out_hi32 = 0;\r\n\r\n total_out_before = pfile_in_zip_read_info->bstream.total_out_lo32;\r\n buf_before = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;\r\n\r\n err = BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);\r\n\r\n total_out_after = pfile_in_zip_read_info->bstream.total_out_lo32;\r\n out_bytes = total_out_after-total_out_before;\r\n\r\n pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + out_bytes;\r\n pfile_in_zip_read_info->rest_read_uncompressed -= out_bytes;\r\n pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,buf_before, (uInt)(out_bytes));\r\n\r\n read += (uInt)(total_out_after - total_out_before);\r\n\r\n pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in;\r\n pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in;\r\n pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32;\r\n pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out;\r\n pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;\r\n pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;\r\n\r\n if (err == BZ_STREAM_END)\r\n return (read == 0) ? UNZ_EOF : read;\r\n if (err != BZ_OK)\r\n break;\r\n#endif\r\n }\r\n else\r\n {\r\n ZPOS64_T total_out_before, total_out_after;\r\n const Bytef *buf_before;\r\n ZPOS64_T out_bytes;\r\n int flush=Z_SYNC_FLUSH;\r\n\r\n total_out_before = pfile_in_zip_read_info->stream.total_out;\r\n buf_before = pfile_in_zip_read_info->stream.next_out;\r\n\r\n /*\r\n if ((pfile_in_zip_read_info->rest_read_uncompressed ==\r\n pfile_in_zip_read_info->stream.avail_out) &&\r\n (pfile_in_zip_read_info->rest_read_compressed == 0))\r\n flush = Z_FINISH;\r\n */\r\n err = inflate(&pfile_in_zip_read_info->stream,flush);\r\n\r\n if ((err >= 0) && (pfile_in_zip_read_info->stream.msg != NULL))\r\n err = Z_DATA_ERROR;\r\n\r\n total_out_after = pfile_in_zip_read_info->stream.total_out;\r\n out_bytes = total_out_after-total_out_before;\r\n\r\n pfile_in_zip_read_info->total_out_64 += out_bytes;\r\n pfile_in_zip_read_info->rest_read_uncompressed -= out_bytes;\r\n pfile_in_zip_read_info->crc32 =\r\n crc32(pfile_in_zip_read_info->crc32,buf_before, (uInt)(out_bytes));\r\n\r\n read += (uInt)(total_out_after - total_out_before);\r\n\r\n if (err == Z_STREAM_END)\r\n return (read == 0) ? UNZ_EOF : read;\r\n if (err != Z_OK)\r\n break;\r\n }\r\n }\r\n\r\n if (err == Z_OK)\r\n return read;\r\n return err;\r\n}\r\n\r\nextern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64(unzFile file)\r\n{\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n s = (unz64_s*)file;\r\n if (file == NULL)\r\n return 0; /* UNZ_PARAMERROR */\r\n pfile_in_zip_read_info= s->pfile_in_zip_read;\r\n if (pfile_in_zip_read_info == NULL)\r\n return 0; /* UNZ_PARAMERROR */\r\n return pfile_in_zip_read_info->pos_in_zipfile + pfile_in_zip_read_info->byte_before_the_zipfile;\r\n}\r\n\r\nextern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, unsigned len)\r\n{\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n uInt read_now;\r\n ZPOS64_T size_to_read;\r\n\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info = s->pfile_in_zip_read;\r\n\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_PARAMERROR;\r\n\r\n size_to_read = pfile_in_zip_read_info->size_local_extrafield - pfile_in_zip_read_info->pos_local_extrafield;\r\n\r\n if (buf == NULL)\r\n return (int)size_to_read;\r\n\r\n if (len > size_to_read)\r\n read_now = (uInt)size_to_read;\r\n else\r\n read_now = (uInt)len ;\r\n\r\n if (read_now == 0)\r\n return 0;\r\n\r\n if (ZSEEK64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream,\r\n pfile_in_zip_read_info->offset_local_extrafield + pfile_in_zip_read_info->pos_local_extrafield,\r\n ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return UNZ_ERRNO;\r\n\r\n if (ZREAD64(pfile_in_zip_read_info->z_filefunc, pfile_in_zip_read_info->filestream, buf, read_now) != read_now)\r\n return UNZ_ERRNO;\r\n\r\n return (int)read_now;\r\n}\r\n\r\nextern int ZEXPORT unzCloseCurrentFile(unzFile file)\r\n{\r\n int err = UNZ_OK;\r\n\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info=s->pfile_in_zip_read;\r\n\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_PARAMERROR;\r\n\r\n#ifdef HAVE_AES\r\n if (s->cur_file_info.compression_method == AES_METHOD)\r\n {\r\n unsigned char authcode[AES_AUTHCODESIZE];\r\n unsigned char rauthcode[AES_AUTHCODESIZE];\r\n\r\n if (ZREAD64(s->z_filefunc, s->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE)\r\n return UNZ_ERRNO;\r\n\r\n if (fcrypt_end(rauthcode, &s->pfile_in_zip_read->aes_ctx) != AES_AUTHCODESIZE)\r\n err = UNZ_CRCERROR;\r\n if (memcmp(authcode, rauthcode, AES_AUTHCODESIZE) != 0)\r\n err = UNZ_CRCERROR;\r\n }\r\n /* AES zip version AE-1 will expect a valid crc as well */\r\n if ((s->cur_file_info.compression_method != AES_METHOD) ||\r\n (s->cur_file_info_internal.aes_version == 0x0001))\r\n#endif\r\n {\r\n if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&\r\n (!pfile_in_zip_read_info->raw))\r\n {\r\n if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)\r\n err = UNZ_CRCERROR;\r\n }\r\n }\r\n\r\n TRYFREE(pfile_in_zip_read_info->read_buffer);\r\n pfile_in_zip_read_info->read_buffer = NULL;\r\n if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)\r\n inflateEnd(&pfile_in_zip_read_info->stream);\r\n#ifdef HAVE_BZIP2\r\n else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)\r\n BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);\r\n#endif\r\n\r\n pfile_in_zip_read_info->stream_initialised = 0;\r\n TRYFREE(pfile_in_zip_read_info);\r\n\r\n s->pfile_in_zip_read = NULL;\r\n\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)\r\n{\r\n int err = UNZ_OK;\r\n unz64_s* s;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n s->pos_in_central_dir = s->offset_central_dir;\r\n s->num_file = 0;\r\n err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal,\r\n filename,filename_size, extrafield,extrafield_size, comment,comment_size);\r\n s->current_file_ok = (err == UNZ_OK);\r\n if ((err == UNZ_OK) && (pfile_info != NULL))\r\n memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGoToFirstFile(unzFile file)\r\n{\r\n return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);\r\n}\r\n\r\nextern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,\r\n uLong filename_size, void *extrafield, uLong extrafield_size, char *comment, uLong comment_size)\r\n{\r\n unz64_s* s;\r\n int err;\r\n\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n if (!s->current_file_ok)\r\n return UNZ_END_OF_LIST_OF_FILE;\r\n if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */\r\n if (s->num_file+1 == s->gi.number_entry)\r\n return UNZ_END_OF_LIST_OF_FILE;\r\n s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +\r\n s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment;\r\n s->num_file++;\r\n err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, &s->cur_file_info_internal,\r\n filename, filename_size, extrafield,extrafield_size, comment,comment_size);\r\n s->current_file_ok = (err == UNZ_OK);\r\n if ((err == UNZ_OK) && (pfile_info != NULL))\r\n memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64));\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGoToNextFile(unzFile file)\r\n{\r\n return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0);\r\n}\r\n\r\nextern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func)\r\n{\r\n unz64_s* s;\r\n int err;\r\n unz_file_info64 cur_file_info_saved;\r\n unz_file_info64_internal cur_file_info_internal_saved;\r\n ZPOS64_T num_file_saved;\r\n ZPOS64_T pos_in_central_dir_saved;\r\n char current_filename[UNZ_MAXFILENAMEINZIP+1];\r\n\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n if (strlen(filename) >= UNZ_MAXFILENAMEINZIP)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n if (!s->current_file_ok)\r\n return UNZ_END_OF_LIST_OF_FILE;\r\n\r\n /* Save the current state */\r\n num_file_saved = s->num_file;\r\n pos_in_central_dir_saved = s->pos_in_central_dir;\r\n cur_file_info_saved = s->cur_file_info;\r\n cur_file_info_internal_saved = s->cur_file_info_internal;\r\n\r\n err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);\r\n\r\n while (err == UNZ_OK)\r\n {\r\n if (filename_compare_func != NULL)\r\n err = filename_compare_func(file, current_filename, filename);\r\n else\r\n err = strcmp(current_filename, filename);\r\n if (err == 0)\r\n return UNZ_OK;\r\n err = unzGoToNextFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0);\r\n }\r\n\r\n /* We failed, so restore the state of the 'current file' to where we were. */\r\n s->num_file = num_file_saved;\r\n s->pos_in_central_dir = pos_in_central_dir_saved;\r\n s->cur_file_info = cur_file_info_saved;\r\n s->cur_file_info_internal = cur_file_info_internal_saved;\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos* file_pos)\r\n{\r\n unz64_file_pos file_pos64;\r\n int err = unzGetFilePos64(file,&file_pos64);\r\n if (err == UNZ_OK)\r\n {\r\n file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;\r\n file_pos->num_of_file = (uLong)file_pos64.num_of_file;\r\n }\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos* file_pos)\r\n{\r\n unz64_file_pos file_pos64;\r\n\r\n if (file_pos == NULL)\r\n return UNZ_PARAMERROR;\r\n file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;\r\n file_pos64.num_of_file = file_pos->num_of_file;\r\n return unzGoToFilePos64(file,&file_pos64);\r\n}\r\n\r\nextern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)\r\n{\r\n unz64_s* s;\r\n\r\n if (file == NULL || file_pos == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n if (!s->current_file_ok)\r\n return UNZ_END_OF_LIST_OF_FILE;\r\n\r\n file_pos->pos_in_zip_directory = s->pos_in_central_dir;\r\n file_pos->num_of_file = s->num_file;\r\n\r\n return UNZ_OK;\r\n}\r\n\r\nextern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)\r\n{\r\n unz64_s* s;\r\n int err;\r\n\r\n if (file == NULL || file_pos == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n\r\n /* jump to the right spot */\r\n s->pos_in_central_dir = file_pos->pos_in_zip_directory;\r\n s->num_file = file_pos->num_of_file;\r\n\r\n /* set the current file */\r\n err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info, &s->cur_file_info_internal,NULL,0,NULL,0,NULL,0);\r\n /* return results */\r\n s->current_file_ok = (err == UNZ_OK);\r\n return err;\r\n}\r\n\r\nextern uLong ZEXPORT unzGetOffset(unzFile file)\r\n{\r\n ZPOS64_T offset64;\r\n\r\n if (file == NULL)\r\n return 0; /* UNZ_PARAMERROR; */\r\n offset64 = unzGetOffset64(file);\r\n return (uLong)offset64;\r\n}\r\n\r\nextern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)\r\n{\r\n unz64_s* s;\r\n\r\n if (file == NULL)\r\n return 0; /* UNZ_PARAMERROR; */\r\n s = (unz64_s*)file;\r\n if (!s->current_file_ok)\r\n return 0;\r\n if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)\r\n if (s->num_file == s->gi.number_entry)\r\n return 0;\r\n return s->pos_in_central_dir;\r\n}\r\n\r\nextern int ZEXPORT unzSetOffset(unzFile file, uLong pos)\r\n{\r\n return unzSetOffset64(file, pos);\r\n}\r\n\r\nextern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)\r\n{\r\n unz64_s* s;\r\n int err;\r\n\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n\r\n s->pos_in_central_dir = pos;\r\n s->num_file = s->gi.number_entry; /* hack */\r\n err = unz64local_GetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0);\r\n s->current_file_ok = (err == UNZ_OK);\r\n return err;\r\n}\r\n\r\nextern z_off_t ZEXPORT unztell(unzFile file)\r\n{\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info=s->pfile_in_zip_read;\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_PARAMERROR;\r\n return (z_off_t)pfile_in_zip_read_info->stream.total_out;\r\n}\r\n\r\nextern ZPOS64_T ZEXPORT unztell64(unzFile file)\r\n{\r\n\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n if (file == NULL)\r\n return (ZPOS64_T)-1;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info = s->pfile_in_zip_read;\r\n\r\n if (pfile_in_zip_read_info == NULL)\r\n return (ZPOS64_T)-1;\r\n\r\n return pfile_in_zip_read_info->total_out_64;\r\n}\r\n\r\nextern int ZEXPORT unzeof(unzFile file)\r\n{\r\n unz64_s* s;\r\n file_in_zip64_read_info_s* pfile_in_zip_read_info;\r\n if (file == NULL)\r\n return UNZ_PARAMERROR;\r\n s = (unz64_s*)file;\r\n pfile_in_zip_read_info = s->pfile_in_zip_read;\r\n\r\n if (pfile_in_zip_read_info == NULL)\r\n return UNZ_PARAMERROR;\r\n\r\n if (pfile_in_zip_read_info->rest_read_uncompressed == 0)\r\n return 1;\r\n return 0;\r\n}\r\n"
},
{
"path": "libs/minizip/source/unzipper.cpp",
"content": "#include \"unzipper.h\"\r\n#include \"defs.h\"\r\n#include \"tools.h\"\r\n\r\n#include <functional>\r\n#include <exception>\r\n#include <fstream>\r\n#include <stdexcept>\r\n\r\nnamespace zipper {\r\n\r\n struct Unzipper::Impl\r\n {\r\n Unzipper& m_outer;\r\n zipFile m_zf;\r\n ourmemory_t m_zipmem;\r\n zlib_filefunc_def m_filefunc;\r\n\r\n private:\r\n\r\n bool initMemory(zlib_filefunc_def& filefunc)\r\n {\r\n m_zf = unzOpen2(\"__notused__\", &filefunc);\r\n return m_zf != NULL;\r\n }\r\n\r\n bool locateEntry(const std::string& name)\r\n {\r\n return UNZ_OK == unzLocateFile(m_zf, name.c_str(), NULL);\r\n }\r\n\r\n ZipEntry currentEntryInfo()\r\n {\r\n unz_file_info64 file_info = { 0 };\r\n char filename_inzip[256] = { 0 };\r\n\r\n int err = unzGetCurrentFileInfo64(m_zf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);\r\n if (UNZ_OK != err)\r\n throw EXCEPTION_CLASS(\"Error, couln't get the current entry info\");\r\n\r\n return ZipEntry(std::string(filename_inzip), file_info.compressed_size, file_info.uncompressed_size,\r\n file_info.tmu_date.tm_year, file_info.tmu_date.tm_mon, file_info.tmu_date.tm_mday,\r\n file_info.tmu_date.tm_hour, file_info.tmu_date.tm_min, file_info.tmu_date.tm_sec, file_info.dosDate);\r\n }\r\n\r\n#if 0\r\n // lambda as a parameter https://en.wikipedia.org/wiki/C%2B%2B11#Polymorphic_wrappers_for_function_objects\r\n void iterEntries(std::function<void(ZipEntry&)> callback)\r\n {\r\n int err = unzGoToFirstFile(m_zf);\r\n if (UNZ_OK == err)\r\n {\r\n do\r\n {\r\n ZipEntry entryinfo = currentEntryInfo();\r\n\r\n if (entryinfo.valid())\r\n {\r\n callback(entryinfo);\r\n err = unzGoToNextFile(m_zf);\r\n }\r\n else\r\n err = UNZ_ERRNO;\r\n\r\n } while (UNZ_OK == err);\r\n\r\n if (UNZ_END_OF_LIST_OF_FILE != err && UNZ_OK != err)\r\n return;\r\n }\r\n }\r\n#endif\r\n\r\n void getEntries(std::vector<ZipEntry>& entries)\r\n {\r\n int err = unzGoToFirstFile(m_zf);\r\n if (UNZ_OK == err)\r\n {\r\n do\r\n {\r\n ZipEntry entryinfo = currentEntryInfo();\r\n\r\n if (entryinfo.valid())\r\n {\r\n entries.push_back(entryinfo);\r\n err = unzGoToNextFile(m_zf);\r\n }\r\n else\r\n err = UNZ_ERRNO;\r\n\r\n } while (UNZ_OK == err);\r\n\r\n if (UNZ_END_OF_LIST_OF_FILE != err && UNZ_OK != err)\r\n return;\r\n }\r\n }\r\n\r\n\r\n public:\r\n#if 0\r\n bool extractCurrentEntry(ZipEntry& entryinfo, int (extractStrategy)(ZipEntry&) )\r\n {\r\n int err = UNZ_OK;\r\n\r\n if (!entryinfo.valid())\r\n return false;\r\n\r\n err = extractStrategy(entryinfo);\r\n if (UNZ_OK == err)\r\n {\r\n err = unzCloseCurrentFile(m_zf);\r\n if (UNZ_OK != err)\r\n throw EXCEPTION_CLASS((\"Error \" + std::to_string(err) + \" closing internal file '\" + entryinfo.name +\r\n \"' in zip\").c_str());\r\n }\r\n\r\n return UNZ_OK == err;\r\n }\r\n#endif\r\n\r\n bool extractCurrentEntryToFile(ZipEntry& entryinfo, const std::string& fileName)\r\n {\r\n int err = UNZ_OK;\r\n\r\n if (!entryinfo.valid())\r\n return false;\r\n\r\n err = extractToFile(fileName, entryinfo);\r\n if (UNZ_OK == err)\r\n {\r\n err = unzCloseCurrentFile(m_zf);\r\n if (UNZ_OK != err)\r\n {\r\n std::stringstream str;\r\n str << \"Error \" << err << \" openinginternal file '\" \r\n << entryinfo.name << \"' in zip\";\r\n\r\n throw EXCEPTION_CLASS(str.str().c_str());\r\n }\r\n }\r\n\r\n return UNZ_OK == err;\r\n }\r\n\r\n bool extractCurrentEntryToStream(ZipEntry& entryinfo, std::ostream& stream)\r\n {\r\n int err = UNZ_OK;\r\n\r\n if (!entryinfo.valid())\r\n return false;\r\n\r\n err = extractToStream(stream, entryinfo);\r\n if (UNZ_OK == err)\r\n {\r\n err = unzCloseCurrentFile(m_zf);\r\n if (UNZ_OK != err)\r\n {\r\n std::stringstream str;\r\n str << \"Error \" << err << \" opening internal file '\" \r\n << entryinfo.name << \"' in zip\";\r\n\r\n throw EXCEPTION_CLASS(str.str().c_str());\r\n }\r\n }\r\n\r\n return UNZ_OK == err;\r\n }\r\n\r\n bool extractCurrentEntryToMemory(ZipEntry& entryinfo, std::vector<unsigned char>& outvec)\r\n {\r\n int err = UNZ_OK;\r\n\r\n if (!entryinfo.valid())\r\n return false;\r\n\r\n err = extractToMemory(outvec, entryinfo);\r\n if (UNZ_OK == err)\r\n {\r\n err = unzCloseCurrentFile(m_zf);\r\n if (UNZ_OK != err)\r\n {\r\n std::stringstream str;\r\n str << \"Error \" << err << \" opening internal file '\" \r\n << entryinfo.name << \"' in zip\";\r\n\r\n throw EXCEPTION_CLASS(str.str().c_str());\r\n }\r\n }\r\n\r\n return UNZ_OK == err;\r\n }\r\n\r\n void changeFileDate(const std::string& filename, uLong dosdate, tm_unz tmu_date)\r\n {\r\n#ifdef _WIN32\r\n HANDLE hFile;\r\n FILETIME ftm, ftLocal, ftCreate, ftLastAcc, ftLastWrite;\r\n\r\n hFile = CreateFileA(filename.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);\r\n if (hFile != INVALID_HANDLE_VALUE)\r\n {\r\n GetFileTime(hFile, &ftCreate, &ftLastAcc, &ftLastWrite);\r\n DosDateTimeToFileTime((WORD)(dosdate >> 16), (WORD)dosdate, &ftLocal);\r\n LocalFileTimeToFileTime(&ftLocal, &ftm);\r\n SetFileTime(hFile, &ftm, &ftLastAcc, &ftm);\r\n CloseHandle(hFile);\r\n }\r\n#else\r\n#if defined unix || defined __APPLE__\r\n struct utimbuf ut;\r\n struct tm newdate;\r\n\r\n newdate.tm_sec = tmu_date.tm_sec;\r\n newdate.tm_min = tmu_date.tm_min;\r\n newdate.tm_hour = tmu_date.tm_hour;\r\n newdate.tm_mday = tmu_date.tm_mday;\r\n newdate.tm_mon = tmu_date.tm_mon;\r\n if (tmu_date.tm_year > 1900)\r\n newdate.tm_year = tmu_date.tm_year - 1900;\r\n else\r\n newdate.tm_year = tmu_date.tm_year;\r\n newdate.tm_isdst = -1;\r\n\r\n ut.actime = ut.modtime = mktime(&newdate);\r\n utime(filename.c_str(), &ut);\r\n#endif\r\n#endif\r\n }\r\n\r\n\r\n int extractToFile(const std::string& filename, ZipEntry& info)\r\n {\r\n int err = UNZ_ERRNO;\r\n\r\n /* If zip entry is a directory then create it on disk */\r\n makedir(parentDirectory(filename));\r\n\r\n /* Create the file on disk so we can unzip to it */\r\n std::ofstream output_file(filename.c_str(), std::ofstream::binary);\r\n\r\n if (output_file.good())\r\n {\r\n if (extractToStream(output_file, info))\r\n err = UNZ_OK;\r\n\r\n output_file.close();\r\n\r\n /* Set the time of the file that has been unzipped */\r\n tm_unz timeaux;\r\n memcpy(&timeaux, &info.unixdate, sizeof(timeaux));\r\n\r\n changeFileDate(filename, info.dosdate, timeaux);\r\n }\r\n else\r\n output_file.close();\r\n\r\n return err;\r\n }\r\n\r\n int extractToStream(std::ostream& stream, ZipEntry& info)\r\n {\r\n size_t err = UNZ_ERRNO;\r\n\r\n err = unzOpenCurrentFilePassword(m_zf, m_outer.m_password.c_str());\r\n if (UNZ_OK != err)\r\n {\r\n std::stringstream str;\r\n str << \"Error \" << err << \" opening internal file '\" \r\n << info.name << \"' in zip\";\r\n\r\n throw EXCEPTION_CLASS(str.str().c_str());\r\n }\r\n\r\n std::vector<char> buffer;\r\n buffer.resize(WRITEBUFFERSIZE);\r\n\r\n do\r\n {\r\n err = unzReadCurrentFile(m_zf, buffer.data(), (unsigned int)buffer.size());\r\n if (err < 0 || err == 0)\r\n break;\r\n\r\n stream.write(buffer.data(), err);\r\n if (!stream.good())\r\n {\r\n err = UNZ_ERRNO;\r\n break;\r\n }\r\n\r\n } while (err > 0);\r\n\r\n stream.flush();\r\n\r\n return (int)err;\r\n }\r\n\r\n int extractToMemory(std::vector<unsigned char>& outvec, ZipEntry& info)\r\n {\r\n size_t err = UNZ_ERRNO;\r\n\r\n err = unzOpenCurrentFilePassword(m_zf, m_outer.m_password.c_str());\r\n if (UNZ_OK != err)\r\n {\r\n std::stringstream str;\r\n str << \"Error \" << err << \" opening internal file '\" \r\n << info.name << \"' in zip\";\r\n\r\n throw EXCEPTION_CLASS(str.str().c_str());\r\n }\r\n\r\n std::vector<unsigned char> buffer;\r\n buffer.resize(WRITEBUFFERSIZE);\r\n\r\n outvec.reserve((size_t)info.uncompressedSize);\r\n\r\n do\r\n {\r\n err = unzReadCurrentFile(m_zf, buffer.data(), (unsigned int)buffer.size());\r\n if (err < 0 || err == 0)\r\n break;\r\n\r\n outvec.insert(outvec.end(), buffer.data(), buffer.data() + err);\r\n\r\n } while (err > 0);\r\n\r\n return (int)err;\r\n }\r\n\r\n public:\r\n\r\n Impl(Unzipper& outer) : m_outer(outer), m_zipmem(), m_filefunc()\r\n {\r\n m_zf = NULL;\r\n }\r\n\r\n ~Impl()\r\n {\r\n }\r\n\r\n void close()\r\n {\r\n if (m_zf)\r\n unzClose(m_zf);\r\n }\r\n\r\n bool initFile(const std::string& filename)\r\n {\r\n#ifdef USEWIN32IOAPI\r\n zlib_filefunc64_def ffunc;\r\n fill_win32_filefunc64A(&ffunc);\r\n m_zf = unzOpen2_64(filename.c_str(), &ffunc);\r\n#else\r\n m_zf = unzOpen64(filename.c_str());\r\n#endif\r\n return m_zf != NULL;\r\n }\r\n\r\n bool initWithStream(std::istream& stream)\r\n {\r\n stream.seekg(0, std::ios::end);\r\n size_t size = (size_t)stream.tellg();\r\n stream.seekg(0);\r\n\r\n if (size > 0)\r\n {\r\n m_zipmem.base = new char[(size_t)size];\r\n stream.read(m_zipmem.base, size);\r\n }\r\n\r\n fill_memory_filefunc(&m_filefunc, &m_zipmem);\r\n\r\n return initMemory(m_filefunc);\r\n }\r\n\r\n bool initWithVector(std::vector<unsigned char>& buffer)\r\n {\r\n if (!buffer.empty())\r\n {\r\n m_zipmem.base = (char*)buffer.data();\r\n m_zipmem.size = (uLong)buffer.size();\r\n }\r\n\r\n fill_memory_filefunc(&m_filefunc, &m_zipmem);\r\n\r\n return initMemory(m_filefunc);\r\n }\r\n\r\n std::vector<ZipEntry> entries()\r\n {\r\n std::vector<ZipEntry> entrylist;\r\n getEntries(entrylist);\r\n return entrylist;\r\n }\r\n\r\n \r\n\r\n bool extractAll(const std::string& destination, const std::map<std::string, std::string>& alternativeNames)\r\n {\r\n std::vector<ZipEntry> entries;\r\n getEntries(entries);\r\n std::vector<ZipEntry>::iterator it = entries.begin();\r\n for (; it != entries.end(); ++it)\r\n {\r\n if (!locateEntry(it->name))\r\n continue;\r\n\r\n std::string alternativeName = destination.empty() ? \"\" : destination + \"/\";\r\n\r\n if (alternativeNames.find(it->name) != alternativeNames.end())\r\n alternativeName += alternativeNames.at(it->name);\r\n else\r\n alternativeName += it->name;\r\n\r\n this->extractCurrentEntryToFile(*it, alternativeName);\r\n };\r\n\r\n return true;\r\n }\r\n\r\n bool extractEntry(const std::string& name, const std::string& destination)\r\n {\r\n std::string outputFile = destination.empty() ? name : destination + \"\\\\\" + name;\r\n\r\n if (locateEntry(name))\r\n {\r\n ZipEntry entry = currentEntryInfo();\r\n return extractCurrentEntryToFile(entry, outputFile);\r\n }\r\n else\r\n {\r\n return false;\r\n }\r\n }\r\n\r\n bool extractEntryToStream(const std::string& name, std::ostream& stream)\r\n {\r\n if (locateEntry(name))\r\n {\r\n ZipEntry entry = currentEntryInfo();\r\n return extractCurrentEntryToStream(entry, stream);\r\n }\r\n else\r\n {\r\n return false;\r\n }\r\n }\r\n\r\n bool extractEntryToMemory(const std::string& name, std::vector<unsigned char>& vec)\r\n {\r\n if (locateEntry(name))\r\n {\r\n ZipEntry entry = currentEntryInfo();\r\n return extractCurrentEntryToMemory(entry, vec);\r\n }\r\n else\r\n {\r\n return false;\r\n }\r\n }\r\n };\r\n\r\n Unzipper::Unzipper(std::istream& zippedBuffer)\r\n : m_ibuffer(zippedBuffer)\r\n , m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n , m_usingMemoryVector(false)\r\n , m_usingStream(true)\r\n , m_impl(new Impl(*this))\r\n {\r\n if (!m_impl->initWithStream(m_ibuffer))\r\n throw EXCEPTION_CLASS(\"Error loading zip in memory!\");\r\n m_open = true;\r\n }\r\n\r\n Unzipper::Unzipper(std::vector<unsigned char>& zippedBuffer)\r\n : m_ibuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n , m_vecbuffer(zippedBuffer)\r\n , m_usingMemoryVector(true)\r\n , m_usingStream(false)\r\n , m_impl(new Impl(*this))\r\n {\r\n if (!m_impl->initWithVector(m_vecbuffer))\r\n throw EXCEPTION_CLASS(\"Error loading zip in memory!\");\r\n\r\n m_open = true;\r\n }\r\n\r\n Unzipper::Unzipper(const std::string& zipname)\r\n : m_ibuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n , m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n , m_zipname(zipname)\r\n , m_usingMemoryVector(false)\r\n , m_usingStream(false)\r\n , m_impl(new Impl(*this))\r\n {\r\n if (!m_impl->initFile(zipname))\r\n throw EXCEPTION_CLASS(\"Error loading zip file!\");\r\n\r\n m_open = true;\r\n }\r\n\r\n Unzipper::Unzipper(const std::string& zipname, const std::string& password)\r\n : m_ibuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n , m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n , m_zipname(zipname)\r\n , m_password(password)\r\n , m_usingMemoryVector(false)\r\n , m_usingStream(false)\r\n , m_impl(new Impl(*this))\r\n {\r\n if (!m_impl->initFile(zipname))\r\n throw EXCEPTION_CLASS(\"Error loading zip file!\");\r\n\r\n m_open = true;\r\n }\r\n\r\n Unzipper::~Unzipper(void)\r\n {\r\n close();\r\n }\r\n\r\n std::vector<ZipEntry> Unzipper::entries()\r\n {\r\n return m_impl->entries();\r\n }\r\n\r\n bool Unzipper::extractEntry(const std::string& name, const std::string& destination)\r\n {\r\n return m_impl->extractEntry(name, destination);\r\n }\r\n\r\n bool Unzipper::extractEntryToStream(const std::string& name, std::ostream& stream)\r\n {\r\n return m_impl->extractEntryToStream(name, stream);\r\n }\r\n\r\n bool Unzipper::extractEntryToMemory(const std::string& name, std::vector<unsigned char>& vec)\r\n {\r\n return m_impl->extractEntryToMemory(name, vec);\r\n }\r\n\r\n\r\n bool Unzipper::extract(const std::string& destination, const std::map<std::string, std::string>& alternativeNames)\r\n {\r\n return m_impl->extractAll(destination, alternativeNames);\r\n }\r\n\r\n bool \r\n Unzipper::extract(const std::string& destination)\r\n {\r\n return m_impl->extractAll(destination, std::map<std::string, std::string>());\r\n }\r\n\r\n void Unzipper::close()\r\n {\r\n if (m_open)\r\n {\r\n m_impl->close();\r\n m_open = false;\r\n }\r\n }\r\n\r\n}\r\n\r\n"
},
{
"path": "libs/minizip/source/zip.c",
"content": "/* zip.c -- IO on .zip files using zlib\r\n Version 1.1, February 14h, 2010\r\n part of the MiniZip project\r\n\r\n Copyright (C) 1998-2010 Gilles Vollant\r\n http://www.winimage.com/zLibDll/minizip.html\r\n Modifications for Zip64 support\r\n Copyright (C) 2009-2010 Mathias Svensson\r\n http://result42.com\r\n Modifications for AES, PKWARE disk spanning\r\n Copyright (C) 2010-2014 Nathan Moinvaziri\r\n\r\n This program is distributed under the terms of the same license as zlib.\r\n See the accompanying LICENSE file for the full text of the license.\r\n*/\r\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n#include <time.h>\r\n#include \"zlib.h\"\r\n#include \"zip.h\"\r\n\r\n#ifdef STDC\r\n# include <stddef.h>\r\n# include <string.h>\r\n# include <stdlib.h>\r\n#endif\r\n#ifdef NO_ERRNO_H\r\n extern int errno;\r\n#else\r\n# include <errno.h>\r\n#endif\r\n\r\n#ifdef HAVE_AES\r\n# define AES_METHOD (99)\r\n# define AES_PWVERIFYSIZE (2)\r\n# define AES_AUTHCODESIZE (10)\r\n# define AES_MAXSALTLENGTH (16)\r\n# define AES_VERSION (0x0001)\r\n# define AES_ENCRYPTIONMODE (0x03)\r\n\r\n# include \"aes/aes.h\"\r\n# include \"aes/fileenc.h\"\r\n# include \"aes/prng.h\"\r\n# include \"aes/entropy.h\"\r\n#endif\r\n\r\n#ifndef NOCRYPT\r\n# define INCLUDECRYPTINGCODE_IFCRYPTALLOWED\r\n# include \"crypt.h\"\r\n#endif\r\n\r\n#ifndef local\r\n# define local static\r\n#endif\r\n/* compile with -Dlocal if your debugger can't find static symbols */\r\n\r\n#define SIZEDATA_INDATABLOCK (4096-(4*4))\r\n\r\n#define DISKHEADERMAGIC (0x08074b50)\r\n#define LOCALHEADERMAGIC (0x04034b50)\r\n#define CENTRALHEADERMAGIC (0x02014b50)\r\n#define ENDHEADERMAGIC (0x06054b50)\r\n#define ZIP64ENDHEADERMAGIC (0x06064b50)\r\n#define ZIP64ENDLOCHEADERMAGIC (0x07064b50)\r\n\r\n#define FLAG_LOCALHEADER_OFFSET (0x06)\r\n#define CRC_LOCALHEADER_OFFSET (0x0e)\r\n\r\n#define SIZECENTRALHEADER (0x2e) /* 46 */\r\n#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */\r\n#define SIZECENTRALDIRITEM (0x2e)\r\n#define SIZEZIPLOCALHEADER (0x1e)\r\n\r\n#ifndef BUFREADCOMMENT\r\n# define BUFREADCOMMENT (0x400)\r\n#endif\r\n#ifndef VERSIONMADEBY\r\n# define VERSIONMADEBY (0x0) /* platform dependent */\r\n#endif\r\n\r\n#ifndef Z_BUFSIZE\r\n# define Z_BUFSIZE (64*1024)\r\n#endif\r\n#ifndef Z_MAXFILENAMEINZIP\r\n# define Z_MAXFILENAMEINZIP (256)\r\n#endif\r\n\r\n#ifndef ALLOC\r\n# define ALLOC(size) (malloc(size))\r\n#endif\r\n#ifndef TRYFREE\r\n# define TRYFREE(p) {if (p) free(p);}\r\n#endif\r\n\r\n/* NOT sure that this work on ALL platform */\r\n#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))\r\n\r\n#ifndef DEF_MEM_LEVEL\r\n# if MAX_MEM_LEVEL >= 8\r\n# define DEF_MEM_LEVEL 8\r\n# else\r\n# define DEF_MEM_LEVEL MAX_MEM_LEVEL\r\n# endif\r\n#endif\r\n\r\nconst char zip_copyright[] = \" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll\";\r\n\r\ntypedef struct linkedlist_datablock_internal_s\r\n{\r\n struct linkedlist_datablock_internal_s* next_datablock;\r\n uLong avail_in_this_block;\r\n uLong filled_in_this_block;\r\n uLong unused; /* for future use and alignment */\r\n unsigned char data[SIZEDATA_INDATABLOCK];\r\n} linkedlist_datablock_internal;\r\n\r\ntypedef struct linkedlist_data_s\r\n{\r\n linkedlist_datablock_internal* first_block;\r\n linkedlist_datablock_internal* last_block;\r\n} linkedlist_data;\r\n\r\ntypedef struct\r\n{\r\n z_stream stream; /* zLib stream structure for inflate */\r\n#ifdef HAVE_BZIP2\r\n bz_stream bstream; /* bzLib stream structure for bziped */\r\n#endif\r\n#ifdef HAVE_AES\r\n fcrypt_ctx aes_ctx;\r\n prng_ctx aes_rng[1];\r\n#endif\r\n int stream_initialised; /* 1 is stream is initialized */\r\n uInt pos_in_buffered_data; /* last written byte in buffered_data */\r\n\r\n ZPOS64_T pos_local_header; /* offset of the local header of the file currently writing */\r\n char* central_header; /* central header data for the current file */\r\n uLong size_centralextra;\r\n uLong size_centralheader; /* size of the central header for cur file */\r\n uLong size_centralextrafree; /* Extra bytes allocated to the central header but that are not used */\r\n uLong size_comment;\r\n uLong flag; /* flag of the file currently writing */\r\n\r\n int method; /* compression method written to file.*/\r\n int compression_method; /* compression method to use */\r\n int raw; /* 1 for directly writing raw data */\r\n Byte buffered_data[Z_BUFSIZE]; /* buffer contain compressed data to be writ*/\r\n uLong dosDate;\r\n uLong crc32;\r\n int zip64; /* Add ZIP64 extended information in the extra field */\r\n uLong number_disk; /* number of current disk used for spanning ZIP */\r\n ZPOS64_T pos_zip64extrainfo;\r\n ZPOS64_T total_compressed;\r\n ZPOS64_T total_uncompressed;\r\n#ifndef NOCRYPT\r\n unsigned long keys[3]; /* keys defining the pseudo-random sequence */\r\n const unsigned long* pcrc_32_tab;\r\n int crypt_header_size;\r\n#endif\r\n} curfile64_info;\r\n\r\ntypedef struct\r\n{\r\n zlib_filefunc64_32_def z_filefunc;\r\n voidpf filestream; /* io structure of the zipfile */\r\n voidpf filestream_with_CD; /* io structure of the zipfile with the central dir */\r\n linkedlist_data central_dir; /* datablock with central dir in construction*/\r\n int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/\r\n int append; /* append mode */\r\n curfile64_info ci; /* info on the file currently writing */\r\n\r\n ZPOS64_T begin_pos; /* position of the beginning of the zipfile */\r\n ZPOS64_T add_position_when_writting_offset;\r\n ZPOS64_T number_entry;\r\n ZPOS64_T disk_size; /* size of each disk */\r\n uLong number_disk; /* number of the current disk, used for spanning ZIP */\r\n uLong number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n char *globalcomment;\r\n#endif\r\n} zip64_internal;\r\n\r\n/* Allocate a new data block */\r\nlocal linkedlist_datablock_internal* allocate_new_datablock OF(());\r\nlocal linkedlist_datablock_internal* allocate_new_datablock()\r\n{\r\n linkedlist_datablock_internal* ldi;\r\n\r\n ldi = (linkedlist_datablock_internal*)ALLOC(sizeof(linkedlist_datablock_internal));\r\n\r\n if (ldi != NULL)\r\n {\r\n ldi->next_datablock = NULL;\r\n ldi->filled_in_this_block = 0;\r\n ldi->avail_in_this_block = SIZEDATA_INDATABLOCK;\r\n }\r\n return ldi;\r\n}\r\n\r\n/* Free data block in linked list */\r\nlocal void free_datablock OF((linkedlist_datablock_internal* ldi));\r\nlocal void free_datablock(linkedlist_datablock_internal* ldi)\r\n{\r\n while (ldi != NULL)\r\n {\r\n linkedlist_datablock_internal* ldinext = ldi->next_datablock;\r\n TRYFREE(ldi);\r\n ldi = ldinext;\r\n }\r\n}\r\n\r\n/* Initialize linked list */\r\nlocal void init_linkedlist OF((linkedlist_data* ll));\r\nlocal void init_linkedlist(linkedlist_data* ll)\r\n{\r\n ll->first_block = ll->last_block = NULL;\r\n}\r\n\r\n/* Free entire linked list and all data blocks */\r\nlocal void free_linkedlist OF((linkedlist_data* ll));\r\nlocal void free_linkedlist(linkedlist_data* ll)\r\n{\r\n free_datablock(ll->first_block);\r\n ll->first_block = ll->last_block = NULL;\r\n}\r\n\r\n/* Add data to linked list data block */\r\nlocal int add_data_in_datablock OF((linkedlist_data* ll, const void* buf, uLong len));\r\nlocal int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)\r\n{\r\n linkedlist_datablock_internal* ldi;\r\n const unsigned char* from_copy;\r\n\r\n if (ll == NULL)\r\n return ZIP_INTERNALERROR;\r\n\r\n if (ll->last_block == NULL)\r\n {\r\n ll->first_block = ll->last_block = allocate_new_datablock();\r\n if (ll->first_block == NULL)\r\n return ZIP_INTERNALERROR;\r\n }\r\n\r\n ldi = ll->last_block;\r\n from_copy = (unsigned char*)buf;\r\n\r\n while (len>0)\r\n {\r\n uInt copy_this;\r\n uInt i;\r\n unsigned char* to_copy;\r\n\r\n if (ldi->avail_in_this_block == 0)\r\n {\r\n ldi->next_datablock = allocate_new_datablock();\r\n if (ldi->next_datablock == NULL)\r\n return ZIP_INTERNALERROR;\r\n ldi = ldi->next_datablock ;\r\n ll->last_block = ldi;\r\n }\r\n\r\n if (ldi->avail_in_this_block < len)\r\n copy_this = (uInt)ldi->avail_in_this_block;\r\n else\r\n copy_this = (uInt)len;\r\n\r\n to_copy = &(ldi->data[ldi->filled_in_this_block]);\r\n\r\n for (i=0;i<copy_this;i++)\r\n *(to_copy+i)=*(from_copy+i);\r\n\r\n ldi->filled_in_this_block += copy_this;\r\n ldi->avail_in_this_block -= copy_this;\r\n from_copy += copy_this ;\r\n len -= copy_this;\r\n }\r\n return ZIP_OK;\r\n}\r\n\r\nlocal uLong zip64local_TmzDateToDosDate OF((const tm_zip* ptm));\r\nlocal uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)\r\n{\r\n uLong year;\r\n#define zip64local_in_range(min, max, value) ((min) <= (value) && (value) <= (max))\r\n /* Years supported:\r\n * [00, 79] (assumed to be between 2000 and 2079)\r\n * [80, 207] (assumed to be between 1980 and 2107, typical output of old\r\n software that does 'year-1900' to get a double digit year)\r\n * [1980, 2107]\r\n Due to the date format limitations, only years between 1980 and 2107 can be stored.\r\n */\r\n if (!(zip64local_in_range(1980, 2107, ptm->tm_year) || zip64local_in_range(0, 207, ptm->tm_year)) ||\r\n !zip64local_in_range(0, 11, ptm->tm_mon) ||\r\n !zip64local_in_range(1, 31, ptm->tm_mday) ||\r\n !zip64local_in_range(0, 23, ptm->tm_hour) ||\r\n !zip64local_in_range(0, 59, ptm->tm_min) ||\r\n !zip64local_in_range(0, 59, ptm->tm_sec))\r\n return 0;\r\n#undef zip64local_in_range\r\n\r\n year = (uLong)ptm->tm_year;\r\n if (year >= 1980) /* range [1980, 2107] */\r\n year -= 1980;\r\n else if (year >= 80) /* range [80, 99] */\r\n year -= 80;\r\n else /* range [00, 79] */\r\n year += 20;\r\n\r\n return\r\n (uLong)(((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |\r\n ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));\r\n}\r\n\r\n/* Inputs a long in LSB order to the given file: nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T) */\r\nlocal int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n ZPOS64_T x, int nbByte));\r\nlocal int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n ZPOS64_T x, int nbByte)\r\n{\r\n unsigned char buf[8];\r\n int n;\r\n for (n = 0; n < nbByte; n++)\r\n {\r\n buf[n] = (unsigned char)(x & 0xff);\r\n x >>= 8;\r\n }\r\n if (x != 0)\r\n {\r\n /* data overflow - hack for ZIP64 (X Roche) */\r\n for (n = 0; n < nbByte; n++)\r\n {\r\n buf[n] = 0xff;\r\n }\r\n }\r\n\r\n if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)\r\n return ZIP_ERRNO;\r\n\r\n return ZIP_OK;\r\n}\r\n\r\nlocal void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));\r\nlocal void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)\r\n{\r\n unsigned char* buf =(unsigned char*)dest;\r\n int n;\r\n for (n = 0; n < nbByte; n++) {\r\n buf[n] = (unsigned char)(x & 0xff);\r\n x >>= 8;\r\n }\r\n\r\n if (x != 0)\r\n {\r\n /* data overflow - hack for ZIP64 */\r\n for (n = 0; n < nbByte; n++)\r\n {\r\n buf[n] = 0xff;\r\n }\r\n }\r\n}\r\n\r\nlocal int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));\r\nlocal int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)\r\n{\r\n unsigned char c;\r\n int err = (int)ZREAD64(*pzlib_filefunc_def, filestream, &c,1);\r\n if (err == 1)\r\n {\r\n *pi = (int)c;\r\n return ZIP_OK;\r\n }\r\n if (ZERROR64(*pzlib_filefunc_def, filestream))\r\n return ZIP_ERRNO;\r\n return ZIP_EOF;\r\n}\r\n\r\nlocal int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));\r\nlocal int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)\r\n{\r\n uLong x;\r\n int i = 0;\r\n int err;\r\n\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (uLong)i;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((uLong)i) << 8;\r\n\r\n if (err == ZIP_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n return err;\r\n}\r\n\r\nlocal int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));\r\nlocal int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)\r\n{\r\n uLong x;\r\n int i = 0;\r\n int err;\r\n\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (uLong)i;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((uLong)i)<<8;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((uLong)i)<<16;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((uLong)i)<<24;\r\n\r\n if (err == ZIP_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n return err;\r\n}\r\n\r\nlocal int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));\r\nlocal int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)\r\n{\r\n ZPOS64_T x;\r\n int i = 0;\r\n int err;\r\n\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x = (ZPOS64_T)i;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<8;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<16;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<24;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<32;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<40;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<48;\r\n if (err == ZIP_OK)\r\n err = zip64local_getByte(pzlib_filefunc_def, filestream, &i);\r\n x += ((ZPOS64_T)i)<<56;\r\n\r\n if (err == ZIP_OK)\r\n *pX = x;\r\n else\r\n *pX = 0;\r\n\r\n return err;\r\n}\r\n\r\n/* Gets the amount of bytes left to write to the current disk for spanning archives */\r\nlocal int zipGetDiskSizeAvailable OF((zipFile file, ZPOS64_T *size_available));\r\nlocal int zipGetDiskSizeAvailable(zipFile file, ZPOS64_T *size_available)\r\n{\r\n zip64_internal* zi;\r\n ZPOS64_T current_disk_size;\r\n\r\n zi = (zip64_internal*)file;\r\n ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END);\r\n current_disk_size = ZTELL64(zi->z_filefunc, zi->filestream);\r\n *size_available = zi->disk_size - current_disk_size;\r\n return ZIP_OK;\r\n}\r\n\r\n/* Goes to a specific disk number for spanning archives */\r\nlocal int zipGoToSpecificDisk OF((zipFile file, int number_disk, int open_existing));\r\nlocal int zipGoToSpecificDisk(zipFile file, int number_disk, int open_existing)\r\n{\r\n zip64_internal* zi;\r\n int err = ZIP_OK;\r\n\r\n zi = (zip64_internal*)file;\r\n if (zi->disk_size == 0)\r\n return err;\r\n\r\n if ((zi->filestream != NULL) && (zi->filestream != zi->filestream_with_CD))\r\n ZCLOSE64(zi->z_filefunc, zi->filestream);\r\n\r\n zi->filestream = ZOPENDISK64(zi->z_filefunc, zi->filestream_with_CD, number_disk, (open_existing == 1) ?\r\n (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING) :\r\n (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE));\r\n\r\n if (zi->filestream == NULL)\r\n err = ZIP_ERRNO;\r\n\r\n return err;\r\n}\r\n\r\n/* Goes to the first disk in a spanned archive */\r\nlocal int zipGoToFirstDisk OF((zipFile file));\r\nlocal int zipGoToFirstDisk(zipFile file)\r\n{\r\n zip64_internal* zi;\r\n int number_disk_next;\r\n int err = ZIP_OK;\r\n\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->disk_size == 0)\r\n return err;\r\n number_disk_next = 0;\r\n if (zi->number_disk_with_CD > 0)\r\n number_disk_next = zi->number_disk_with_CD - 1;\r\n err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP));\r\n if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP))\r\n err = zipGoToSpecificDisk(file, number_disk_next, 0);\r\n if (err == ZIP_OK)\r\n zi->number_disk = number_disk_next;\r\n ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END);\r\n return err;\r\n}\r\n\r\n/* Goes to the next disk in a spanned archive */\r\nlocal int zipGoToNextDisk OF((zipFile file));\r\nlocal int zipGoToNextDisk(zipFile file)\r\n{\r\n zip64_internal* zi;\r\n ZPOS64_T size_available_in_disk;\r\n int err = ZIP_OK;\r\n int number_disk_next;\r\n\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->disk_size == 0)\r\n return err;\r\n\r\n number_disk_next = zi->number_disk + 1;\r\n\r\n do\r\n {\r\n err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP));\r\n if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP))\r\n err = zipGoToSpecificDisk(file, number_disk_next, 0);\r\n if (err != ZIP_OK)\r\n break;\r\n err = zipGetDiskSizeAvailable(file, &size_available_in_disk);\r\n if (err != ZIP_OK)\r\n break;\r\n zi->number_disk = number_disk_next;\r\n zi->number_disk_with_CD = zi->number_disk + 1;\r\n\r\n number_disk_next += 1;\r\n }\r\n while (size_available_in_disk <= 0);\r\n\r\n return err;\r\n}\r\n\r\n/* Locate the Central directory of a zipfile (at the end, just before the global comment) */\r\nlocal ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));\r\nlocal ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)\r\n{\r\n unsigned char* buf;\r\n ZPOS64_T file_size;\r\n ZPOS64_T back_read = 4;\r\n ZPOS64_T max_back=0xffff; /* maximum size of global comment */\r\n ZPOS64_T pos_found=0;\r\n uLong read_size;\r\n ZPOS64_T read_pos;\r\n int i;\r\n\r\n buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);\r\n if (buf == NULL)\r\n return 0;\r\n\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0)\r\n {\r\n TRYFREE(buf);\r\n return 0;\r\n }\r\n\r\n file_size = ZTELL64(*pzlib_filefunc_def, filestream);\r\n\r\n if (max_back > file_size)\r\n max_back = file_size;\r\n\r\n while (back_read < max_back)\r\n {\r\n if (back_read + BUFREADCOMMENT > max_back)\r\n back_read = max_back;\r\n else\r\n back_read += BUFREADCOMMENT;\r\n\r\n read_pos = file_size-back_read;\r\n read_size = ((BUFREADCOMMENT+4) < (file_size-read_pos)) ?\r\n (BUFREADCOMMENT+4) : (uLong)(file_size-read_pos);\r\n\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n break;\r\n if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size)\r\n break;\r\n\r\n for (i = (int)read_size-3; (i--) > 0;)\r\n if ((*(buf+i)) == (ENDHEADERMAGIC & 0xff) &&\r\n (*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff) &&\r\n (*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff) &&\r\n (*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff))\r\n {\r\n pos_found = read_pos+i;\r\n break;\r\n }\r\n\r\n if (pos_found != 0)\r\n break;\r\n }\r\n TRYFREE(buf);\r\n return pos_found;\r\n}\r\n\r\n/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */\r\nlocal ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n const ZPOS64_T endcentraloffset));\r\nlocal ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,\r\n const ZPOS64_T endcentraloffset)\r\n{\r\n ZPOS64_T offset;\r\n uLong uL;\r\n\r\n /* Zip64 end of central directory locator */\r\n if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return 0;\r\n\r\n /* read locator signature */\r\n if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)\r\n return 0;\r\n if (uL != ZIP64ENDLOCHEADERMAGIC)\r\n return 0;\r\n /* number of the disk with the start of the zip64 end of central directory */\r\n if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)\r\n return 0;\r\n /* relative offset of the zip64 end of central directory record */\r\n if (zip64local_getLong64(pzlib_filefunc_def, filestream, &offset) != ZIP_OK)\r\n return 0;\r\n /* total number of disks */\r\n if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)\r\n return 0;\r\n /* Goto end of central directory record */\r\n if (ZSEEK64(*pzlib_filefunc_def,filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n return 0;\r\n /* the signature */\r\n if (zip64local_getLong(pzlib_filefunc_def, filestream, &uL) != ZIP_OK)\r\n return 0;\r\n if (uL != ZIP64ENDHEADERMAGIC)\r\n return 0;\r\n\r\n return offset;\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen4(const void *pathname, int append, ZPOS64_T disk_size, zipcharpc* globalcomment,\r\n zlib_filefunc64_32_def* pzlib_filefunc64_32_def)\r\n{\r\n zip64_internal ziinit;\r\n zip64_internal* zi;\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n ZPOS64_T byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx)*/\r\n ZPOS64_T size_central_dir; /* size of the central directory */\r\n ZPOS64_T offset_central_dir; /* offset of start of central directory */\r\n ZPOS64_T number_entry_CD; /* total number of entries in the central dir */\r\n ZPOS64_T number_entry;\r\n ZPOS64_T central_pos;\r\n ZPOS64_T size_central_dir_to_read;\r\n uLong uL;\r\n uLong size_comment;\r\n size_t buf_size = SIZEDATA_INDATABLOCK;\r\n void* buf_read;\r\n#endif\r\n int err = ZIP_OK;\r\n int mode;\r\n\r\n ziinit.z_filefunc.zseek32_file = NULL;\r\n ziinit.z_filefunc.ztell32_file = NULL;\r\n if (pzlib_filefunc64_32_def == NULL)\r\n fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);\r\n else\r\n ziinit.z_filefunc = *pzlib_filefunc64_32_def;\r\n\r\n if (append == APPEND_STATUS_CREATE)\r\n mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE);\r\n else\r\n mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING);\r\n\r\n ziinit.filestream = ZOPEN64(ziinit.z_filefunc, pathname, mode);\r\n if (ziinit.filestream == NULL)\r\n return NULL;\r\n\r\n if (append == APPEND_STATUS_CREATEAFTER)\r\n {\r\n /* Don't support spanning ZIP with APPEND_STATUS_CREATEAFTER */\r\n if (disk_size > 0)\r\n return NULL;\r\n\r\n ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);\r\n }\r\n\r\n ziinit.filestream_with_CD = ziinit.filestream;\r\n ziinit.append = append;\r\n ziinit.number_disk = 0;\r\n ziinit.number_disk_with_CD = 0;\r\n ziinit.disk_size = disk_size;\r\n ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);\r\n ziinit.in_opened_file_inzip = 0;\r\n ziinit.ci.stream_initialised = 0;\r\n ziinit.number_entry = 0;\r\n ziinit.add_position_when_writting_offset = 0;\r\n init_linkedlist(&(ziinit.central_dir));\r\n\r\n zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));\r\n if (zi == NULL)\r\n {\r\n ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);\r\n return NULL;\r\n }\r\n\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n /* Add file in a zipfile */\r\n ziinit.globalcomment = NULL;\r\n if (append == APPEND_STATUS_ADDINZIP)\r\n {\r\n /* Read and Cache Central Directory Records */\r\n central_pos = zip64local_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);\r\n /* disable to allow appending to empty ZIP archive (must be standard zip, not zip64)\r\n if (central_pos == 0)\r\n err = ZIP_ERRNO;\r\n */\r\n\r\n if (err == ZIP_OK)\r\n {\r\n /* read end of central directory info */\r\n if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n\r\n /* the signature, already checked */\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* number of this disk */\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* number of the disk with the start of the central directory */\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk_with_CD) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* total number of entries in the central dir on this disk */\r\n number_entry = 0;\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n else\r\n number_entry = uL;\r\n /* total number of entries in the central dir */\r\n number_entry_CD = 0;\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n else\r\n number_entry_CD = uL;\r\n if (number_entry_CD!=number_entry)\r\n err = ZIP_BADZIPFILE;\r\n /* size of the central directory */\r\n size_central_dir = 0;\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n else\r\n size_central_dir = uL;\r\n /* offset of start of central directory with respect to the starting disk number */\r\n offset_central_dir = 0;\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n else\r\n offset_central_dir = uL;\r\n /* zipfile global comment length */\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &size_comment) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n\r\n if ((err == ZIP_OK) && ((number_entry_CD == 0xffff) || (offset_central_dir == 0xffffffff)))\r\n {\r\n /* Format should be Zip64, as the central directory or file size is too large */\r\n central_pos = zip64local_SearchCentralDir64(&ziinit.z_filefunc, ziinit.filestream, central_pos);\r\n\r\n if (central_pos)\r\n {\r\n ZPOS64_T sizeEndOfCentralDirectory;\r\n\r\n if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n\r\n /* the signature, already checked */\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* size of zip64 end of central directory record */\r\n if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &sizeEndOfCentralDirectory) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* version made by */\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* version needed to extract */\r\n if (zip64local_getShort(&ziinit.z_filefunc, ziinit.filestream, &uL) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* number of this disk */\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* number of the disk with the start of the central directory */\r\n if (zip64local_getLong(&ziinit.z_filefunc, ziinit.filestream, &ziinit.number_disk_with_CD) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* total number of entries in the central directory on this disk */\r\n if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &number_entry) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* total number of entries in the central directory */\r\n if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &number_entry_CD) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n if (number_entry_CD!=number_entry)\r\n err = ZIP_BADZIPFILE;\r\n /* size of the central directory */\r\n if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &size_central_dir) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n /* offset of start of central directory with respect to the starting disk number */\r\n if (zip64local_getLong64(&ziinit.z_filefunc, ziinit.filestream, &offset_central_dir) != ZIP_OK)\r\n err = ZIP_ERRNO;\r\n }\r\n else\r\n err = ZIP_BADZIPFILE;\r\n }\r\n }\r\n\r\n if ((err == ZIP_OK) && (central_pos<offset_central_dir+size_central_dir))\r\n err = ZIP_BADZIPFILE;\r\n\r\n if (err != ZIP_OK)\r\n {\r\n ZCLOSE64(ziinit.z_filefunc, ziinit.filestream);\r\n TRYFREE(zi);\r\n return NULL;\r\n }\r\n\r\n if (size_comment > 0)\r\n {\r\n ziinit.globalcomment = (char*)ALLOC(size_comment+1);\r\n if (ziinit.globalcomment)\r\n {\r\n size_comment = ZREAD64(ziinit.z_filefunc, ziinit.filestream, ziinit.globalcomment, size_comment);\r\n ziinit.globalcomment[size_comment] = 0;\r\n }\r\n }\r\n\r\n byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);\r\n ziinit.add_position_when_writting_offset = byte_before_the_zipfile;\r\n\r\n /* Store central directory in memory */\r\n size_central_dir_to_read = size_central_dir;\r\n buf_size = SIZEDATA_INDATABLOCK;\r\n buf_read = (void*)ALLOC(buf_size);\r\n\r\n if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream,\r\n offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n\r\n while ((size_central_dir_to_read > 0) && (err == ZIP_OK))\r\n {\r\n ZPOS64_T read_this = SIZEDATA_INDATABLOCK;\r\n if (read_this > size_central_dir_to_read)\r\n read_this = size_central_dir_to_read;\r\n\r\n if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, buf_read, (uLong)read_this) != read_this)\r\n err = ZIP_ERRNO;\r\n\r\n if (err == ZIP_OK)\r\n err = add_data_in_datablock(&ziinit.central_dir, buf_read, (uLong)read_this);\r\n\r\n size_central_dir_to_read -= read_this;\r\n }\r\n TRYFREE(buf_read);\r\n\r\n ziinit.begin_pos = byte_before_the_zipfile;\r\n ziinit.number_entry = number_entry_CD;\r\n\r\n if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream,\r\n offset_central_dir+byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n if (globalcomment)\r\n *globalcomment = ziinit.globalcomment;\r\n#endif\r\n\r\n if (err != ZIP_OK)\r\n {\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n TRYFREE(ziinit.globalcomment);\r\n#endif\r\n TRYFREE(zi);\r\n return NULL;\r\n }\r\n\r\n *zi = ziinit;\r\n zipGoToFirstDisk((zipFile)zi);\r\n return(zipFile)zi;\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen2(const char *pathname, int append, zipcharpc* globalcomment,\r\n zlib_filefunc_def* pzlib_filefunc32_def)\r\n{\r\n if (pzlib_filefunc32_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);\r\n return zipOpen4(pathname, append, 0, globalcomment, &zlib_filefunc64_32_def_fill);\r\n }\r\n return zipOpen4(pathname, append, 0, globalcomment, NULL);\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen2_64(const void *pathname, int append, zipcharpc* globalcomment,\r\n zlib_filefunc64_def* pzlib_filefunc_def)\r\n{\r\n if (pzlib_filefunc_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;\r\n zlib_filefunc64_32_def_fill.ztell32_file = NULL;\r\n zlib_filefunc64_32_def_fill.zseek32_file = NULL;\r\n return zipOpen4(pathname, append, 0, globalcomment, &zlib_filefunc64_32_def_fill);\r\n }\r\n return zipOpen4(pathname, append, 0, globalcomment, NULL);\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen3(const char *pathname, int append, ZPOS64_T disk_size, zipcharpc* globalcomment,\r\n zlib_filefunc_def* pzlib_filefunc32_def)\r\n{\r\n if (pzlib_filefunc32_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);\r\n return zipOpen4(pathname, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill);\r\n }\r\n return zipOpen4(pathname, append, disk_size, globalcomment, NULL);\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen3_64(const void *pathname, int append, ZPOS64_T disk_size, zipcharpc* globalcomment,\r\n zlib_filefunc64_def* pzlib_filefunc_def)\r\n{\r\n if (pzlib_filefunc_def != NULL)\r\n {\r\n zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;\r\n zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;\r\n zlib_filefunc64_32_def_fill.ztell32_file = NULL;\r\n zlib_filefunc64_32_def_fill.zseek32_file = NULL;\r\n return zipOpen4(pathname, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill);\r\n }\r\n return zipOpen4(pathname, append, disk_size, globalcomment, NULL);\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen(const char* pathname, int append)\r\n{\r\n return zipOpen3((const void*)pathname,append,0,NULL,NULL);\r\n}\r\n\r\nextern zipFile ZEXPORT zipOpen64(const void* pathname, int append)\r\n{\r\n return zipOpen3(pathname,append,0,NULL,NULL);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits, int memLevel,\r\n int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase, int zip64)\r\n{\r\n zip64_internal* zi;\r\n uInt size_filename;\r\n uInt size_comment = 0;\r\n uInt i;\r\n int err = ZIP_OK;\r\n ZPOS64_T size_available;\r\n ZPOS64_T size_needed;\r\n\r\n#ifdef NOCRYPT\r\n (crcForCrypting);\r\n if (password != NULL)\r\n return ZIP_PARAMERROR;\r\n#endif\r\n\r\n if (file == NULL)\r\n return ZIP_PARAMERROR;\r\n\r\n if ((method != 0) &&\r\n#ifdef HAVE_BZIP2\r\n (method != Z_BZIP2ED) &&\r\n#endif\r\n (method != Z_DEFLATED))\r\n return ZIP_PARAMERROR;\r\n\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->in_opened_file_inzip == 1)\r\n {\r\n err = zipCloseFileInZip (file);\r\n if (err != ZIP_OK)\r\n return err;\r\n }\r\n\r\n if (filename == NULL)\r\n filename = \"-\";\r\n if (comment != NULL)\r\n size_comment = (uInt)strlen(comment);\r\n\r\n size_filename = (uInt)strlen(filename);\r\n\r\n if (zipfi == NULL)\r\n zi->ci.dosDate = 0;\r\n else\r\n {\r\n if (zipfi->dosDate != 0)\r\n zi->ci.dosDate = zipfi->dosDate;\r\n else\r\n zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);\r\n }\r\n\r\n zi->ci.method = method;\r\n zi->ci.compression_method = method;\r\n zi->ci.crc32 = 0;\r\n zi->ci.stream_initialised = 0;\r\n zi->ci.pos_in_buffered_data = 0;\r\n zi->ci.raw = raw;\r\n zi->ci.flag = flagBase;\r\n if ((level == 8) || (level == 9))\r\n zi->ci.flag |= 2;\r\n if (level == 2)\r\n zi->ci.flag |= 4;\r\n if (level == 1)\r\n zi->ci.flag |= 6;\r\n if (password != NULL)\r\n {\r\n zi->ci.flag |= 1;\r\n#ifdef HAVE_AES\r\n zi->ci.method = AES_METHOD;\r\n#endif\r\n }\r\n\r\n if (zi->disk_size > 0)\r\n {\r\n if ((zi->number_disk == 0) && (zi->number_entry == 0))\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)DISKHEADERMAGIC, 4);\r\n\r\n /* Make sure enough space available on current disk for local header */\r\n zipGetDiskSizeAvailable((zipFile)zi, &size_available);\r\n size_needed = 30 + size_filename + size_extrafield_local;\r\n if (zi->ci.zip64)\r\n size_needed += 20;\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n size_needed += 11;\r\n#endif\r\n if (size_available < size_needed)\r\n zipGoToNextDisk((zipFile)zi);\r\n }\r\n\r\n zi->ci.pos_local_header = ZTELL64(zi->z_filefunc, zi->filestream);\r\n zi->ci.size_comment = size_comment;\r\n zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global;\r\n zi->ci.size_centralextra = size_extrafield_global;\r\n zi->ci.size_centralextrafree = 32; /* Extra space reserved for ZIP64 extra info */\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n zi->ci.size_centralextrafree += 11; /* Extra space reserved for AES extra info */\r\n#endif\r\n zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralextrafree + size_comment);\r\n zi->ci.number_disk = zi->number_disk;\r\n\r\n /* Write central directory header */\r\n zip64local_putValue_inmemory(zi->ci.central_header, (uLong)CENTRALHEADERMAGIC, 4);\r\n zip64local_putValue_inmemory(zi->ci.central_header+4, (uLong)versionMadeBy, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+6, (uLong)20, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+8, (uLong)zi->ci.flag, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+10, (uLong)zi->ci.method, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+12, (uLong)zi->ci.dosDate, 4);\r\n zip64local_putValue_inmemory(zi->ci.central_header+16, (uLong)0, 4); /*crc*/\r\n zip64local_putValue_inmemory(zi->ci.central_header+20, (uLong)0, 4); /*compr size*/\r\n zip64local_putValue_inmemory(zi->ci.central_header+24, (uLong)0, 4); /*uncompr size*/\r\n zip64local_putValue_inmemory(zi->ci.central_header+28, (uLong)size_filename, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+30, (uLong)size_extrafield_global, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+32, (uLong)size_comment, 2);\r\n zip64local_putValue_inmemory(zi->ci.central_header+34, (uLong)zi->ci.number_disk, 2); /*disk nm start*/\r\n\r\n if (zipfi == NULL)\r\n zip64local_putValue_inmemory(zi->ci.central_header+36, (uLong)0, 2);\r\n else\r\n zip64local_putValue_inmemory(zi->ci.central_header+36, (uLong)zipfi->internal_fa, 2);\r\n if (zipfi == NULL)\r\n zip64local_putValue_inmemory(zi->ci.central_header+38, (uLong)0, 4);\r\n else\r\n zip64local_putValue_inmemory(zi->ci.central_header+38, (uLong)zipfi->external_fa, 4);\r\n if (zi->ci.pos_local_header >= 0xffffffff)\r\n zip64local_putValue_inmemory(zi->ci.central_header+42, (uLong)0xffffffff, 4);\r\n else\r\n zip64local_putValue_inmemory(zi->ci.central_header+42,\r\n (uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset, 4);\r\n\r\n for (i = 0; i < size_filename; i++)\r\n zi->ci.central_header[SIZECENTRALHEADER+i] = filename[i];\r\n for (i = 0; i < size_extrafield_global; i++)\r\n zi->ci.central_header[SIZECENTRALHEADER+size_filename+i] =\r\n ((const char*)extrafield_global)[i];\r\n /* Store comment at the end for later repositioning */\r\n for (i = 0; i < size_comment; i++)\r\n zi->ci.central_header[zi->ci.size_centralheader+\r\n zi->ci.size_centralextrafree+i] = comment[i];\r\n\r\n if (zi->ci.central_header == NULL)\r\n return ZIP_INTERNALERROR;\r\n\r\n zi->ci.zip64 = zip64;\r\n zi->ci.total_compressed = 0;\r\n zi->ci.total_uncompressed = 0;\r\n zi->ci.pos_zip64extrainfo = 0;\r\n\r\n /* Write the local header */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)LOCALHEADERMAGIC, 4);\r\n\r\n if (err == ZIP_OK)\r\n {\r\n if (zi->ci.zip64)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2); /* version needed to extract */\r\n else\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)20, 2); /* version needed to extract */\r\n }\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.flag, 2);\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.method, 2);\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->ci.dosDate, 4);\r\n\r\n /* CRC & compressed size & uncompressed size will be filled in later and rewritten later */\r\n\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4); /* crc 32, unknown */\r\n if (err == ZIP_OK)\r\n {\r\n if (zi->ci.zip64)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xFFFFFFFF, 4); /* compressed size, unknown */\r\n else\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4); /* compressed size, unknown */\r\n }\r\n if (err == ZIP_OK)\r\n {\r\n if (zi->ci.zip64) /* uncompressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xFFFFFFFF, 4);\r\n else /* uncompressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0, 4);\r\n }\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_filename, 2);\r\n if (err == ZIP_OK)\r\n {\r\n ZPOS64_T size_extrafield = size_extrafield_local;\r\n if (zi->ci.zip64)\r\n size_extrafield += 20;\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n size_extrafield += 11;\r\n#endif\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_extrafield,2);\r\n }\r\n if ((err == ZIP_OK) && (size_filename > 0))\r\n {\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, filename, size_filename) != size_filename)\r\n err = ZIP_ERRNO;\r\n }\r\n if ((err == ZIP_OK) && (size_extrafield_local > 0))\r\n {\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n /* Write the Zip64 extended info */\r\n if ((err == ZIP_OK) && (zi->ci.zip64))\r\n {\r\n short headerid = 1;\r\n short datasize = 16;\r\n ZPOS64_T compressed_size = 0;\r\n ZPOS64_T uncompressed_size = 0;\r\n\r\n /* Remember position of Zip64 extended info for the local file header.\r\n (needed when we update size after done with file) */\r\n zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc, zi->filestream);\r\n\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)headerid, 2);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)datasize, 2);\r\n\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)uncompressed_size, 8);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)compressed_size, 8);\r\n }\r\n#ifdef HAVE_AES\r\n /* Write the AES extended info */\r\n if ((err == ZIP_OK) && (zi->ci.method == AES_METHOD))\r\n {\r\n int headerid = 0x9901;\r\n short datasize = 7;\r\n\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, headerid, 2);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, datasize, 2);\r\n\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, AES_VERSION, 2);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, 'A', 1);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, 'E', 1);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, AES_ENCRYPTIONMODE, 1);\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->ci.compression_method, 2);\r\n }\r\n#endif\r\n\r\n#ifdef HAVE_BZIP2\r\n zi->ci.bstream.avail_in = (uInt)0;\r\n zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;\r\n zi->ci.bstream.total_in_hi32 = 0;\r\n zi->ci.bstream.total_in_lo32 = 0;\r\n zi->ci.bstream.total_out_hi32 = 0;\r\n zi->ci.bstream.total_out_lo32 = 0;\r\n#endif\r\n\r\n zi->ci.stream.avail_in = (uInt)0;\r\n zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.stream.next_out = zi->ci.buffered_data;\r\n zi->ci.stream.total_in = 0;\r\n zi->ci.stream.total_out = 0;\r\n zi->ci.stream.data_type = Z_BINARY;\r\n\r\n if ((err == ZIP_OK) && (!zi->ci.raw))\r\n {\r\n if (method == Z_DEFLATED)\r\n {\r\n zi->ci.stream.zalloc = (alloc_func)0;\r\n zi->ci.stream.zfree = (free_func)0;\r\n zi->ci.stream.opaque = (voidpf)zi;\r\n\r\n if (windowBits > 0)\r\n windowBits = -windowBits;\r\n\r\n err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);\r\n\r\n if (err == Z_OK)\r\n zi->ci.stream_initialised = Z_DEFLATED;\r\n }\r\n else if (method == Z_BZIP2ED)\r\n {\r\n#ifdef HAVE_BZIP2\r\n zi->ci.bstream.bzalloc = 0;\r\n zi->ci.bstream.bzfree = 0;\r\n zi->ci.bstream.opaque = (voidpf)0;\r\n\r\n err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0, 35);\r\n if (err == BZ_OK)\r\n zi->ci.stream_initialised = Z_BZIP2ED;\r\n#endif\r\n }\r\n }\r\n\r\n#ifndef NOCRYPT\r\n zi->ci.crypt_header_size = 0;\r\n if ((err == Z_OK) && ((zi->ci.flag & 1) != 0))\r\n {\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n {\r\n unsigned char passverify[AES_PWVERIFYSIZE];\r\n unsigned char saltvalue[AES_MAXSALTLENGTH];\r\n uInt saltlength;\r\n\r\n if ((AES_ENCRYPTIONMODE < 1) || (AES_ENCRYPTIONMODE > 3))\r\n return Z_ERRNO;\r\n\r\n saltlength = SALT_LENGTH(AES_ENCRYPTIONMODE);\r\n\r\n prng_init(entropy_fun, zi->ci.aes_rng);\r\n prng_rand(saltvalue, saltlength, zi->ci.aes_rng);\r\n prng_end(zi->ci.aes_rng);\r\n\r\n fcrypt_init(AES_ENCRYPTIONMODE, password, strlen(password), saltvalue, passverify, &zi->ci.aes_ctx);\r\n\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, saltvalue, saltlength) != saltlength)\r\n err = ZIP_ERRNO;\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, passverify, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE)\r\n err = ZIP_ERRNO;\r\n\r\n zi->ci.crypt_header_size = saltlength + AES_PWVERIFYSIZE + AES_AUTHCODESIZE;\r\n }\r\n else\r\n#endif\r\n {\r\n unsigned char bufHead[RAND_HEAD_LEN];\r\n unsigned int sizeHead;\r\n\r\n zi->ci.pcrc_32_tab = (const unsigned long *)get_crc_table();\r\n /*init_keys(password, zi->ci.keys, zi->ci.pcrc_32_tab);*/\r\n\r\n sizeHead = crypthead(password, bufHead, RAND_HEAD_LEN, zi->ci.keys, zi->ci.pcrc_32_tab, crcForCrypting);\r\n zi->ci.crypt_header_size = sizeHead;\r\n\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, bufHead, sizeHead) != sizeHead)\r\n err = ZIP_ERRNO;\r\n }\r\n }\r\n#endif\r\n\r\n if (err == Z_OK)\r\n zi->in_opened_file_inzip = 1;\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits,\r\n int memLevel, int strategy, const char* password, uLong crcForCrypting, uLong versionMadeBy, uLong flagBase)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel,\r\n strategy, password, crcForCrypting, versionMadeBy, flagBase, 0);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits,\r\n int memLevel, int strategy, const char* password, uLong crcForCrypting)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel,\r\n strategy, password, crcForCrypting, VERSIONMADEBY, 0, 0);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int windowBits,\r\n int memLevel, int strategy, const char* password, uLong crcForCrypting, int zip64)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, strategy,\r\n password, crcForCrypting, VERSIONMADEBY, 0, zip64);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL,\r\n Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void* extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int raw, int zip64)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL,\r\n Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void*extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level, int zip64)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL,\r\n Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64);\r\n}\r\n\r\nextern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char* filename, const zip_fileinfo* zipfi,\r\n const void* extrafield_local, uInt size_extrafield_local, const void*extrafield_global,\r\n uInt size_extrafield_global, const char* comment, int method, int level)\r\n{\r\n return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local,\r\n extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL,\r\n Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0);\r\n}\r\n\r\n/* Flushes the write buffer to disk */\r\nlocal int zip64FlushWriteBuffer OF((zip64_internal* zi));\r\nlocal int zip64FlushWriteBuffer(zip64_internal* zi)\r\n{\r\n int err = ZIP_OK;\r\n uInt written = 0;\r\n uInt total_written = 0;\r\n uInt write = 0;\r\n uInt max_write = 0;\r\n ZPOS64_T size_available = 0;\r\n\r\n if ((zi->ci.flag & 1) != 0)\r\n {\r\n#ifndef NOCRYPT\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n {\r\n fcrypt_encrypt(zi->ci.buffered_data, zi->ci.pos_in_buffered_data, &zi->ci.aes_ctx);\r\n }\r\n else\r\n#endif\r\n {\r\n uInt i;\r\n int t;\r\n for (i = 0;i < zi->ci.pos_in_buffered_data; i++)\r\n zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);\r\n }\r\n#endif\r\n }\r\n\r\n write = zi->ci.pos_in_buffered_data;\r\n\r\n do\r\n {\r\n max_write = write;\r\n\r\n if (zi->disk_size > 0)\r\n {\r\n err = zipGetDiskSizeAvailable((zipFile)zi, &size_available);\r\n if (err != ZIP_OK)\r\n return err;\r\n\r\n if (size_available == 0)\r\n {\r\n err = zipGoToNextDisk((zipFile)zi);\r\n if (err != ZIP_OK)\r\n return err;\r\n }\r\n\r\n if (size_available < (ZPOS64_T)max_write)\r\n max_write = (uInt)size_available;\r\n }\r\n\r\n written = ZWRITE64(zi->z_filefunc, zi->filestream, zi->ci.buffered_data + total_written, max_write);\r\n\r\n if (ZERROR64(zi->z_filefunc, zi->filestream))\r\n {\r\n err = ZIP_ERRNO;\r\n break;\r\n }\r\n\r\n total_written += written;\r\n write -= written;\r\n }\r\n while (write > 0);\r\n\r\n zi->ci.total_compressed += zi->ci.pos_in_buffered_data;\r\n\r\n#ifdef HAVE_BZIP2\r\n if (zi->ci.compression_method == Z_BZIP2ED)\r\n {\r\n zi->ci.total_uncompressed += zi->ci.bstream.total_in_lo32;\r\n zi->ci.bstream.total_in_lo32 = 0;\r\n zi->ci.bstream.total_in_hi32 = 0;\r\n }\r\n else\r\n#endif\r\n {\r\n zi->ci.total_uncompressed += zi->ci.stream.total_in;\r\n zi->ci.stream.total_in = 0;\r\n }\r\n\r\n zi->ci.pos_in_buffered_data = 0;\r\n\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT zipWriteInFileInZip(zipFile file,const void* buf,unsigned int len)\r\n{\r\n zip64_internal* zi;\r\n int err = ZIP_OK;\r\n\r\n if (file == NULL)\r\n return ZIP_PARAMERROR;\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->in_opened_file_inzip == 0)\r\n return ZIP_PARAMERROR;\r\n\r\n zi->ci.crc32 = crc32(zi->ci.crc32, buf, (uInt)len);\r\n\r\n#ifdef HAVE_BZIP2\r\n if ((zi->ci.compression_method == Z_BZIP2ED) && (!zi->ci.raw))\r\n {\r\n zi->ci.bstream.next_in = (void*)buf;\r\n zi->ci.bstream.avail_in = len;\r\n err = BZ_RUN_OK;\r\n\r\n while ((err == BZ_RUN_OK) && (zi->ci.bstream.avail_in > 0))\r\n {\r\n if (zi->ci.bstream.avail_out == 0)\r\n {\r\n if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)\r\n err = ZIP_ERRNO;\r\n zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;\r\n }\r\n else\r\n {\r\n uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;\r\n uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;\r\n\r\n err = BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);\r\n\r\n zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo);\r\n }\r\n }\r\n\r\n if (err == BZ_RUN_OK)\r\n err = ZIP_OK;\r\n }\r\n else\r\n#endif\r\n {\r\n zi->ci.stream.next_in = (Bytef*)buf;\r\n zi->ci.stream.avail_in = len;\r\n\r\n while ((err == ZIP_OK) && (zi->ci.stream.avail_in > 0))\r\n {\r\n if (zi->ci.stream.avail_out == 0)\r\n {\r\n if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)\r\n err = ZIP_ERRNO;\r\n zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.stream.next_out = zi->ci.buffered_data;\r\n }\r\n\r\n if (err != ZIP_OK)\r\n break;\r\n\r\n if ((zi->ci.compression_method == Z_DEFLATED) && (!zi->ci.raw))\r\n {\r\n uLong total_out_before = zi->ci.stream.total_out;\r\n err = deflate(&zi->ci.stream, Z_NO_FLUSH);\r\n zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - total_out_before);\r\n }\r\n else\r\n {\r\n uInt copy_this,i;\r\n if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)\r\n copy_this = zi->ci.stream.avail_in;\r\n else\r\n copy_this = zi->ci.stream.avail_out;\r\n\r\n for (i = 0; i < copy_this; i++)\r\n *(((char*)zi->ci.stream.next_out)+i) =\r\n *(((const char*)zi->ci.stream.next_in)+i);\r\n\r\n zi->ci.stream.avail_in -= copy_this;\r\n zi->ci.stream.avail_out -= copy_this;\r\n zi->ci.stream.next_in += copy_this;\r\n zi->ci.stream.next_out += copy_this;\r\n zi->ci.stream.total_in += copy_this;\r\n zi->ci.stream.total_out += copy_this;\r\n zi->ci.pos_in_buffered_data += copy_this;\r\n }\r\n }\r\n }\r\n\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uLong uncompressed_size, uLong crc32)\r\n{\r\n return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);\r\n}\r\n\r\nextern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, ZPOS64_T uncompressed_size, uLong crc32)\r\n{\r\n zip64_internal* zi;\r\n ZPOS64_T compressed_size;\r\n uLong invalidValue = 0xffffffff;\r\n uLong i = 0;\r\n short datasize = 0;\r\n int err = ZIP_OK;\r\n\r\n if (file == NULL)\r\n return ZIP_PARAMERROR;\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->in_opened_file_inzip == 0)\r\n return ZIP_PARAMERROR;\r\n zi->ci.stream.avail_in = 0;\r\n\r\n if (!zi->ci.raw)\r\n {\r\n if (zi->ci.compression_method == Z_DEFLATED)\r\n {\r\n while (err == ZIP_OK)\r\n {\r\n uLong total_out_before;\r\n if (zi->ci.stream.avail_out == 0)\r\n {\r\n if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)\r\n err = ZIP_ERRNO;\r\n zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.stream.next_out = zi->ci.buffered_data;\r\n }\r\n total_out_before = zi->ci.stream.total_out;\r\n err = deflate(&zi->ci.stream, Z_FINISH);\r\n zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - total_out_before);\r\n }\r\n }\r\n else if (zi->ci.compression_method == Z_BZIP2ED)\r\n {\r\n#ifdef HAVE_BZIP2\r\n err = BZ_FINISH_OK;\r\n while (err == BZ_FINISH_OK)\r\n {\r\n uLong total_out_before;\r\n if (zi->ci.bstream.avail_out == 0)\r\n {\r\n if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)\r\n err = ZIP_ERRNO;\r\n zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;\r\n zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;\r\n }\r\n total_out_before = zi->ci.bstream.total_out_lo32;\r\n err = BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);\r\n if (err == BZ_STREAM_END)\r\n err = Z_STREAM_END;\r\n zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - total_out_before);\r\n }\r\n\r\n if (err == BZ_FINISH_OK)\r\n err = ZIP_OK;\r\n#endif\r\n }\r\n }\r\n\r\n if (err == Z_STREAM_END)\r\n err = ZIP_OK; /* this is normal */\r\n\r\n if ((zi->ci.pos_in_buffered_data>0) && (err == ZIP_OK))\r\n {\r\n if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n#ifdef HAVE_AES\r\n if (zi->ci.method == AES_METHOD)\r\n {\r\n unsigned char authcode[AES_AUTHCODESIZE];\r\n\r\n fcrypt_end(authcode, &zi->ci.aes_ctx);\r\n\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE)\r\n err = ZIP_ERRNO;\r\n }\r\n#endif\r\n\r\n if (!zi->ci.raw)\r\n {\r\n if (zi->ci.compression_method == Z_DEFLATED)\r\n {\r\n int tmp_err = deflateEnd(&zi->ci.stream);\r\n if (err == ZIP_OK)\r\n err = tmp_err;\r\n zi->ci.stream_initialised = 0;\r\n }\r\n#ifdef HAVE_BZIP2\r\n else if (zi->ci.compression_method == Z_BZIP2ED)\r\n {\r\n int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);\r\n if (err == ZIP_OK)\r\n err = tmperr;\r\n zi->ci.stream_initialised = 0;\r\n }\r\n#endif\r\n\r\n crc32 = (uLong)zi->ci.crc32;\r\n uncompressed_size = zi->ci.total_uncompressed;\r\n }\r\n\r\n compressed_size = zi->ci.total_compressed;\r\n#ifndef NOCRYPT\r\n compressed_size += zi->ci.crypt_header_size;\r\n#endif\r\n\r\n /* Update current item crc and sizes */\r\n if (compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)\r\n {\r\n zip64local_putValue_inmemory(zi->ci.central_header+4, (uLong)45, 2); /* version made by */\r\n zip64local_putValue_inmemory(zi->ci.central_header+6, (uLong)45, 2); /* version needed */\r\n }\r\n zip64local_putValue_inmemory(zi->ci.central_header+16, crc32, 4); /* crc */\r\n if (compressed_size >= 0xffffffff)\r\n zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue, 4); /* compr size */\r\n else\r\n zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size, 4); /* compr size */\r\n if (zi->ci.stream.data_type == Z_ASCII)\r\n zip64local_putValue_inmemory(zi->ci.central_header+36, (uLong)Z_ASCII, 2); /* internal file attrib */\r\n if (uncompressed_size >= 0xffffffff)\r\n zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue, 4); /* uncompr size */\r\n else\r\n zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size, 4); /* uncompr size */\r\n\r\n /* Add ZIP64 extra info field for uncompressed size */\r\n if (uncompressed_size >= 0xffffffff)\r\n datasize += 8;\r\n /* Add ZIP64 extra info field for compressed size */\r\n if (compressed_size >= 0xffffffff)\r\n datasize += 8;\r\n /* Add ZIP64 extra info field for relative offset to local file header of current file */\r\n if (zi->ci.pos_local_header >= 0xffffffff)\r\n datasize += 8;\r\n\r\n /* Add Extra Information Header for 'ZIP64 information' */\r\n if (datasize > 0)\r\n {\r\n char* p = zi->ci.central_header + zi->ci.size_centralheader;\r\n\r\n if ((uLong)(datasize + 4) > zi->ci.size_centralextrafree)\r\n return ZIP_BADZIPFILE;\r\n\r\n zip64local_putValue_inmemory(p, 0x0001, 2);\r\n p += 2;\r\n zip64local_putValue_inmemory(p, datasize, 2);\r\n p += 2;\r\n\r\n if (uncompressed_size >= 0xffffffff)\r\n {\r\n zip64local_putValue_inmemory(p, uncompressed_size, 8);\r\n p += 8;\r\n }\r\n if (compressed_size >= 0xffffffff)\r\n {\r\n zip64local_putValue_inmemory(p, compressed_size, 8);\r\n p += 8;\r\n }\r\n if (zi->ci.pos_local_header >= 0xffffffff)\r\n {\r\n zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);\r\n p += 8;\r\n }\r\n\r\n zi->ci.size_centralextrafree -= datasize + 4;\r\n zi->ci.size_centralheader += datasize + 4;\r\n zi->ci.size_centralextra += datasize + 4;\r\n\r\n zip64local_putValue_inmemory(zi->ci.central_header+30, (uLong)zi->ci.size_centralextra, 2);\r\n }\r\n\r\n#ifdef HAVE_AES\r\n /* Write the AES extended info */\r\n if (zi->ci.method == AES_METHOD)\r\n {\r\n char* p = zi->ci.central_header + zi->ci.size_centralheader;\r\n\r\n datasize = 7;\r\n\r\n if ((uLong)(datasize + 4) > zi->ci.size_centralextrafree)\r\n return ZIP_BADZIPFILE;\r\n\r\n zip64local_putValue_inmemory(p, 0x9901, 2);\r\n p += 2;\r\n zip64local_putValue_inmemory(p, datasize, 2);\r\n p += 2;\r\n zip64local_putValue_inmemory(p, AES_VERSION, 2);\r\n p += 2;\r\n zip64local_putValue_inmemory(p, 'A', 1);\r\n p += 1;\r\n zip64local_putValue_inmemory(p, 'E', 1);\r\n p += 1;\r\n zip64local_putValue_inmemory(p, AES_ENCRYPTIONMODE, 1);\r\n p += 1;\r\n zip64local_putValue_inmemory(p, zi->ci.compression_method, 2);\r\n p += 2;\r\n\r\n zi->ci.size_centralextrafree -= datasize + 4;\r\n zi->ci.size_centralheader += datasize + 4;\r\n zi->ci.size_centralextra += datasize + 4;\r\n\r\n zip64local_putValue_inmemory(zi->ci.central_header+30, (uLong)zi->ci.size_centralextra, 2);\r\n }\r\n#endif\r\n /* Restore comment to correct position */\r\n for (i = 0; i < zi->ci.size_comment; i++)\r\n zi->ci.central_header[zi->ci.size_centralheader+i] =\r\n zi->ci.central_header[zi->ci.size_centralheader+zi->ci.size_centralextrafree+i];\r\n zi->ci.size_centralheader += zi->ci.size_comment;\r\n\r\n if (err == ZIP_OK)\r\n err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);\r\n\r\n free(zi->ci.central_header);\r\n\r\n if (err == ZIP_OK)\r\n {\r\n /* Update the LocalFileHeader with the new values. */\r\n ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream);\r\n uLong cur_number_disk = zi->number_disk;\r\n\r\n /* Local file header is stored on previous disk, switch to make edits */\r\n if (zi->ci.number_disk != cur_number_disk)\r\n err = zipGoToSpecificDisk(file, zi->ci.number_disk, 1);\r\n\r\n if (ZSEEK64(zi->z_filefunc, zi->filestream, zi->ci.pos_local_header + 14, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream,crc32,4); /* crc 32, unknown */\r\n\r\n if (uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff)\r\n {\r\n if (zi->ci.pos_zip64extrainfo > 0)\r\n {\r\n /* Update the size in the ZIP64 extended field. */\r\n if (ZSEEK64(zi->z_filefunc, zi->filestream, zi->ci.pos_zip64extrainfo + 4, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n\r\n if (err == ZIP_OK) /* compressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);\r\n if (err == ZIP_OK) /* uncompressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);\r\n }\r\n else\r\n err = ZIP_BADZIPFILE; /* Caller passed zip64 = 0, so no room for zip64 info -> fatal */\r\n }\r\n else\r\n {\r\n if (err == ZIP_OK) /* compressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream,compressed_size, 4);\r\n if (err == ZIP_OK) /* uncompressed size, unknown */\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream,uncompressed_size, 4);\r\n }\r\n\r\n /* Now switch back again to the disk we were on before */\r\n if (zi->ci.number_disk != cur_number_disk)\r\n err = zipGoToSpecificDisk(file, cur_number_disk, 1);\r\n\r\n if (ZSEEK64(zi->z_filefunc, zi->filestream, cur_pos_inzip, ZLIB_FILEFUNC_SEEK_SET) != 0)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n zi->number_entry++;\r\n zi->in_opened_file_inzip = 0;\r\n\r\n return err;\r\n}\r\n\r\nextern int ZEXPORT zipCloseFileInZip(zipFile file)\r\n{\r\n return zipCloseFileInZipRaw(file, 0, 0);\r\n}\r\n\r\nextern int ZEXPORT zipClose(zipFile file, const char* global_comment)\r\n{\r\n zip64_internal* zi;\r\n int err = 0;\r\n uLong size_centraldir = 0;\r\n uInt size_global_comment = 0;\r\n ZPOS64_T centraldir_pos_inzip;\r\n ZPOS64_T pos = 0;\r\n uLong write = 0;\r\n\r\n if (file == NULL)\r\n return ZIP_PARAMERROR;\r\n\r\n zi = (zip64_internal*)file;\r\n\r\n if (zi->in_opened_file_inzip == 1)\r\n err = zipCloseFileInZip(file);\r\n\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n if (global_comment == NULL)\r\n global_comment = zi->globalcomment;\r\n#endif\r\n\r\n if (zi->filestream != zi->filestream_with_CD)\r\n {\r\n if (ZCLOSE64(zi->z_filefunc, zi->filestream) != 0)\r\n if (err == ZIP_OK)\r\n err = ZIP_ERRNO;\r\n if (zi->disk_size > 0)\r\n zi->number_disk_with_CD = zi->number_disk + 1;\r\n zi->filestream = zi->filestream_with_CD;\r\n }\r\n\r\n centraldir_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream);\r\n\r\n if (err == ZIP_OK)\r\n {\r\n linkedlist_datablock_internal* ldi = zi->central_dir.first_block;\r\n while (ldi!= NULL)\r\n {\r\n if ((err == ZIP_OK) && (ldi->filled_in_this_block > 0))\r\n {\r\n write = ZWRITE64(zi->z_filefunc, zi->filestream, ldi->data, ldi->filled_in_this_block);\r\n if (write != ldi->filled_in_this_block)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n size_centraldir += ldi->filled_in_this_block;\r\n ldi = ldi->next_datablock;\r\n }\r\n }\r\n\r\n free_linkedlist(&(zi->central_dir));\r\n\r\n pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;\r\n\r\n /* Write the ZIP64 central directory header */\r\n if (pos >= 0xffffffff || zi->number_entry > 0xffff)\r\n {\r\n ZPOS64_T zip64eocd_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream);\r\n uLong zip64datasize = 44;\r\n\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ZIP64ENDHEADERMAGIC, 4);\r\n\r\n /* size of this 'zip64 end of central directory' */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)zip64datasize, 8);\r\n /* version made by */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2);\r\n /* version needed */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)45, 2);\r\n /* number of this disk */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4);\r\n /* number of the disk with the start of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4);\r\n /* total number of entries in the central dir on this disk */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);\r\n /* total number of entries in the central dir */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);\r\n /* size of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)size_centraldir, 8);\r\n\r\n if (err == ZIP_OK)\r\n {\r\n /* offset of start of central directory with respect to the starting disk number */\r\n ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)pos, 8);\r\n }\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ZIP64ENDLOCHEADERMAGIC, 4);\r\n\r\n /* number of the disk with the start of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 4);\r\n /*relative offset to the Zip64EndOfCentralDirectory */\r\n if (err == ZIP_OK)\r\n {\r\n ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset;\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, pos, 8);\r\n }\r\n /* number of the disk with the start of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD+1, 4);\r\n }\r\n\r\n /* Write the central directory header */\r\n\r\n /* signature */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)ENDHEADERMAGIC, 4);\r\n /* number of this disk */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 2);\r\n /* number of the disk with the start of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_disk_with_CD, 2);\r\n /* total number of entries in the central dir on this disk */\r\n if (err == ZIP_OK)\r\n {\r\n if (zi->number_entry >= 0xffff)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffff, 2); /* use value in ZIP64 record */\r\n else\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_entry, 2);\r\n }\r\n /* total number of entries in the central dir */\r\n if (err == ZIP_OK)\r\n {\r\n if (zi->number_entry >= 0xffff)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffff, 2); /* use value in ZIP64 record */\r\n else\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)zi->number_entry, 2);\r\n }\r\n /* size of the central directory */\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_centraldir,4);\r\n /* offset of start of central directory with respect to the starting disk number */\r\n if (err == ZIP_OK)\r\n {\r\n ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;\r\n if (pos >= 0xffffffff)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)0xffffffff, 4);\r\n else\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)pos, 4);\r\n }\r\n\r\n /* Write global comment */\r\n\r\n if (global_comment != NULL)\r\n size_global_comment = (uInt)strlen(global_comment);\r\n if (err == ZIP_OK)\r\n err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (uLong)size_global_comment, 2);\r\n if (err == ZIP_OK && size_global_comment > 0)\r\n {\r\n if (ZWRITE64(zi->z_filefunc, zi->filestream, global_comment, size_global_comment) != size_global_comment)\r\n err = ZIP_ERRNO;\r\n }\r\n\r\n if ((ZCLOSE64(zi->z_filefunc, zi->filestream) != 0) && (err == ZIP_OK))\r\n err = ZIP_ERRNO;\r\n\r\n#ifndef NO_ADDFILEINEXISTINGZIP\r\n TRYFREE(zi->globalcomment);\r\n#endif\r\n TRYFREE(zi);\r\n\r\n return err;\r\n}\r\n"
},
{
"path": "libs/minizip/source/zipper.cpp",
"content": "#include \"zipper.h\"\r\n#include \"defs.h\"\r\n#include \"tools.h\"\r\n#include \"CDirEntry.h\"\r\n\r\n#include <fstream>\r\n#include <stdexcept>\r\n\r\nnamespace zipper {\r\n\r\n\tstruct Zipper::Impl\r\n\t{\r\n\t\tZipper& m_outer;\r\n\t\tzipFile m_zf;\r\n\t\tourmemory_t m_zipmem;\r\n\t\tzlib_filefunc_def m_filefunc;\r\n\r\n\t\tImpl(Zipper& outer) : m_outer(outer), m_zipmem(), m_filefunc()\r\n\t\t{\r\n\t\t\tm_zf = NULL;\r\n\t\t\t//m_filefunc = { 0 };\r\n\t\t}\r\n\r\n\t\tbool initFile(const std::string& filename)\r\n\t\t{\r\n\t\t\t#ifdef USEWIN32IOAPI\r\n\t\t\t\tzlib_filefunc64_def ffunc = { 0 };\r\n\t\t\t#endif\r\n\r\n\t\t\tint mode = 0;\r\n\t\t\tint flags = Zipper::Append;\r\n\r\n\t\t\t/* open the zip file for output */\r\n\t\t\tif (checkFileExists(filename))\r\n\t\t\t\tmode = (flags & Zipper::Overwrite) ? APPEND_STATUS_CREATE : APPEND_STATUS_ADDINZIP;\r\n\t\t\telse\r\n\t\t\t\tmode = APPEND_STATUS_CREATE;\r\n\r\n\t\t\t#ifdef USEWIN32IOAPI\r\n\t\t\t\tfill_win32_filefunc64A(&ffunc);\r\n\t\t\t\tm_zf = zipOpen2_64(filename.c_str(), mode, NULL, &ffunc);\r\n\t\t\t#else\r\n\t\t\t\tm_zf = zipOpen64(filename.c_str(), mode);\r\n\t\t\t#endif\r\n\r\n\t\t\treturn NULL != m_zf;\r\n\t\t}\r\n\r\n\t\tbool initWithStream(std::iostream& stream)\r\n\t\t{\r\n\t\t\tm_zipmem.grow = 1;\r\n\r\n\t\t\tstream.seekg(0, std::ios::end);\r\n\t\t\tsize_t size = (size_t)stream.tellg();\r\n\t\t\tstream.seekg(0);\r\n\r\n\t\t\tif (size > 0)\r\n\t\t\t{\r\n\t\t\t\tm_zipmem.base = new char[(size_t)size];\r\n\t\t\t\tstream.read(m_zipmem.base, size);\r\n\t\t\t}\r\n\r\n\t\t\tfill_memory_filefunc(&m_filefunc, &m_zipmem);\r\n\t\t\t\r\n\t\t\treturn initMemory(size > 0 ? APPEND_STATUS_CREATE : APPEND_STATUS_ADDINZIP, m_filefunc);\r\n\t\t}\r\n\r\n\t\tbool initWithVector(std::vector<unsigned char>& buffer)\r\n\t\t{\r\n\t\t\tm_zipmem.grow = 1;\r\n\r\n\t\t\tif (!buffer.empty())\r\n\t\t\t{\r\n\t\t\t\tm_zipmem.base = new char[buffer.size()];\r\n\t\t\t\tmemcpy(m_zipmem.base, (char*)buffer.data(), buffer.size());\r\n\t\t\t\tm_zipmem.size = (uLong)buffer.size();\r\n\t\t\t}\r\n\r\n\t\t\tfill_memory_filefunc(&m_filefunc, &m_zipmem);\r\n\r\n\t\t\treturn initMemory(buffer.empty() ? APPEND_STATUS_CREATE : APPEND_STATUS_ADDINZIP, m_filefunc);\r\n\t\t}\r\n\r\n\t\tbool initMemory(int mode, zlib_filefunc_def& filefunc)\r\n\t\t{\r\n\t\t\tm_zf = zipOpen3(\"__notused__\", mode, 0, 0, &filefunc);\r\n\t\t\treturn m_zf != NULL;\r\n\t\t}\r\n\r\n\t\tbool add(std::istream& input_stream, const std::string& nameInZip, const std::string& password, int flags)\r\n\t\t{\r\n\t\t\tif (!m_zf) return false;\r\n\r\n\t\t\tint compressLevel = 0;\r\n\t\t\tint zip64 = 0;\r\n\t\t\tint size_buf = WRITEBUFFERSIZE;\r\n\t\t\tint err = ZIP_OK;\r\n\t\t\tunsigned long crcFile = 0;\r\n\r\n\t\t\tzip_fileinfo zi = { 0 };\r\n\t\t\tsize_t size_read;\r\n\r\n\t\t\tstd::vector<char> buff;\r\n\t\t\tbuff.resize(size_buf);\r\n\r\n\t\t\tif (nameInZip.empty())\r\n\t\t\t\treturn false;\r\n\r\n\t\t\tif (flags & Zipper::Faster) compressLevel = 1;\r\n\t\t\tif (flags & Zipper::Better) compressLevel = 9;\r\n\r\n\t\t\tzip64 = (int)isLargeFile(input_stream);\r\n\t\t\tif (password.empty())\r\n\t\t\t\terr = zipOpenNewFileInZip64(m_zf,\r\n\t\t\t\t\tnameInZip.c_str(),\r\n\t\t\t\t\t&zi,\r\n\t\t\t\t\tNULL,\r\n\t\t\t\t\t0,\r\n\t\t\t\t\tNULL,\r\n\t\t\t\t\t0,\r\n\t\t\t\t\tNULL /* comment*/,\r\n\t\t\t\t\t(compressLevel != 0) ? Z_DEFLATED : 0,\r\n\t\t\t\t\tcompressLevel,\r\n\t\t\t\t\tzip64);\r\n\t\t\telse\r\n\t\t\t{\r\n\t\t\t\tgetFileCrc(input_stream, buff, crcFile);\r\n\t\t\t\terr = zipOpenNewFileInZip3_64(m_zf,\r\n\t\t\t\t\tnameInZip.c_str(),\r\n\t\t\t\t\t&zi,\r\n\t\t\t\t\tNULL,\r\n\t\t\t\t\t0,\r\n\t\t\t\t\tNULL,\r\n\t\t\t\t\t0,\r\n\t\t\t\t\tNULL /* comment*/,\r\n\t\t\t\t\t(compressLevel != 0) ? Z_DEFLATED : 0,\r\n\t\t\t\t\tcompressLevel,\r\n\t\t\t\t\t0,\r\n\t\t\t\t\t/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */\r\n\t\t\t\t\t-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,\r\n\t\t\t\t\tpassword.c_str(),\r\n\t\t\t\t\tcrcFile,\r\n\t\t\t\t\tzip64);\r\n\t\t\t}\r\n\r\n\t\t\tif (ZIP_OK == err)\r\n\t\t\t{\r\n\t\t\t\tdo {\r\n\t\t\t\t\terr = ZIP_OK;\r\n\t\t\t\t\tinput_stream.read(buff.data(), buff.size());\r\n\t\t\t\t\tsize_read = (size_t)input_stream.gcount();\r\n\t\t\t\t\tif (size_read < buff.size() && !input_stream.eof() && !input_stream.good())\r\n\t\t\t\t\t\terr = ZIP_ERRNO;\r\n\r\n\t\t\t\t\tif (size_read > 0)\r\n\t\t\t\t\t\terr = zipWriteInFileInZip(this->m_zf, buff.data(), (unsigned int)size_read);\r\n\r\n\t\t\t\t} while ((err == ZIP_OK) && (size_read>0));\r\n\t\t\t}\r\n\t\t\telse\r\n\t\t\t\tthrow EXCEPTION_CLASS((\"Error adding '\" + nameInZip + \"' to zip\").c_str());\r\n\r\n\t\t\tif (ZIP_OK == err)\r\n\t\t\t\terr = zipCloseFileInZip(this->m_zf);\r\n\r\n\t\t\treturn ZIP_OK == err;\r\n\t\t}\r\n\r\n\t\tvoid close()\r\n\t\t{\r\n\t\t\tif (m_zf)\r\n\t\t\t\tzipClose(m_zf, NULL);\r\n\r\n\t\t\tif (m_zipmem.base && m_zipmem.limit > 0)\r\n\t\t\t{\r\n\t\t\t\tif (m_outer.m_usingMemoryVector)\r\n\t\t\t\t{\r\n\t\t\t\t\tm_outer.m_vecbuffer.resize(m_zipmem.limit);\r\n\t\t\t\t\tm_outer.m_vecbuffer.assign(m_zipmem.base, m_zipmem.base + m_zipmem.limit);\r\n\t\t\t\t}\r\n\r\n\t\t\t\telse if (m_outer.m_usingStream)\r\n\t\t\t\t\tm_outer.m_obuffer.write(m_zipmem.base, m_zipmem.limit);\r\n\t\t\t}\r\n\r\n\t\t\tfree(m_zipmem.base);\r\n\t\t}\r\n\t};\r\n\r\n\t///////////////////////////////////////////////////////////////////////////////\r\n\t///////////////////////////////////////////////////////////////////////////////\r\n\r\n\tZipper::Zipper(const std::string& zipname)\r\n\t\t: m_obuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n\t\t, m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n\t\t, m_usingMemoryVector(false)\r\n\t\t, m_usingStream(false)\r\n\t\t, m_zipname(zipname)\r\n\t\t, m_impl(new Impl(*this))\r\n\t{\r\n\t\tif (!m_impl->initFile(zipname))\r\n\t\t\tthrow EXCEPTION_CLASS(\"Error creating zip in file!\");\r\n\r\n\t\tm_open = true;\r\n\t}\r\n\r\n\tZipper::Zipper(const std::string& zipname, const std::string& password)\r\n\t\t: m_obuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n\t\t, m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n\t\t, m_usingMemoryVector(false)\r\n\t\t, m_usingStream(false)\r\n\t\t, m_zipname(zipname)\r\n\t\t, m_password(password)\r\n\t\t, m_impl(new Impl(*this))\r\n\t{\r\n\t\tif (!m_impl->initFile(zipname))\r\n\t\t\tthrow EXCEPTION_CLASS(\"Error creating zip in file!\");\r\n\r\n\t\tm_open = true;\r\n\t}\r\n\r\n\tZipper::Zipper(std::iostream& buffer)\r\n\t\t: m_vecbuffer(*(new std::vector<unsigned char>())) //not used but using local variable throws exception\r\n\t\t, m_obuffer(buffer)\r\n\t\t, m_usingMemoryVector(false)\r\n\t\t, m_usingStream(true)\r\n\t\t, m_impl(new Impl(*this))\r\n\t{\r\n\t\tif (!m_impl->initWithStream(m_obuffer))\r\n\t\t\tthrow EXCEPTION_CLASS(\"Error creating zip in memory!\");\r\n\r\n\t\tm_open = true;\r\n\t}\r\n\r\n\tZipper::Zipper(std::vector<unsigned char>& buffer)\r\n\t\t: m_vecbuffer(buffer)\r\n\t\t, m_obuffer(*(new std::stringstream())) //not used but using local variable throws exception\r\n\t\t, m_usingMemoryVector(true)\r\n\t\t, m_usingStream(false)\r\n\t\t, m_impl(new Impl(*this))\r\n\t{\r\n\t\tif (!m_impl->initWithVector(m_vecbuffer))\r\n\t\t\tthrow EXCEPTION_CLASS(\"Error creating zip in memory!\");\r\n\r\n\t\tm_open = true;\r\n\t}\r\n\r\n\tZipper::~Zipper(void)\r\n\t{\r\n\t\tclose();\r\n\t}\r\n\r\n\tbool Zipper::add(std::istream& source, const std::string& nameInZip, zipFlags flags)\r\n\t{\r\n\t\treturn m_impl->add(source, nameInZip, \"\", flags);\r\n\t}\r\n\r\n\tbool Zipper::add(const std::string& fileOrFolderPath, zipFlags flags)\r\n\t{\r\n\t\tif (isDirectory(fileOrFolderPath))\r\n\t\t{\r\n\t\t\tstd::string folderName = fileNameFromPath(fileOrFolderPath);\r\n\t\t\tstd::vector<std::string> files = filesFromDirectory(fileOrFolderPath);\r\n\t\t\tstd::vector<std::string>::iterator it = files.begin();\r\n\t\t\tfor (; it != files.end(); ++it)\r\n\t\t\t{\r\n\t\t\t\tstd::ifstream input(it->c_str(), std::ios::binary);\r\n\t\t\t\tstd::string nameInZip = it->substr(it->rfind(folderName + CDirEntry::Separator), it->size());\r\n\t\t\t\tadd(input, nameInZip, flags);\r\n\t\t\t\tinput.close();\r\n\t\t\t}\r\n\t\t}\r\n\t\telse\r\n\t\t{\r\n\t\t\tstd::ifstream input(fileOrFolderPath.c_str(), std::ios::binary);\r\n\t\t\tadd(input, fileNameFromPath(fileOrFolderPath), flags);\r\n\t\t\tinput.close();\r\n\t\t}\r\n\r\n\t\treturn true;\r\n\t}\r\n\r\n\r\n\tvoid Zipper::open()\r\n\t{\r\n\t\tif (!m_open)\r\n\t\t{\r\n\t\t\tif (m_usingMemoryVector)\r\n\t\t\t{\r\n\t\t\t\tif (!m_impl->initWithVector(m_vecbuffer))\r\n\t\t\t\t\tthrow EXCEPTION_CLASS(\"Error opening zip memory!\");\r\n\t\t\t}\r\n\t\t\telse if (m_usingStream)\r\n\t\t\t{\r\n\t\t\t\tif (!m_impl->initWithStream(m_obuffer))\r\n\t\t\t\t\tthrow EXCEPTION_CLASS(\"Error opening zip memory!\");\r\n\t\t\t}\r\n\t\t\telse\r\n\t\t\t{\r\n\t\t\t\tif (!m_impl->initFile(m_zipname))\r\n\t\t\t\t\tthrow EXCEPTION_CLASS(\"Error opening zip file!\");\r\n\t\t\t}\r\n\r\n\t\t\tm_open = true;\r\n\t\t}\r\n\t}\r\n\r\n\tvoid Zipper::close()\r\n\t{\r\n\t\tif (m_open)\r\n\t\t{\r\n\t\t\tm_impl->close();\r\n\t\t\tm_open = false;\r\n\t\t}\r\n\t}\r\n}\r\n"
},
{
"path": "source/download.cpp",
"content": "\r\n#include \"download.hpp\"\r\n\r\n#define API_AGENT \"HamletDuFromage\"\r\n#define _1MiB 0x100000\r\n\r\ntypedef struct\r\n{\r\n char *memory;\r\n size_t size;\r\n} MemoryStruct_t;\r\n\r\ntypedef struct\r\n{\r\n u_int8_t *data;\r\n size_t data_size;\r\n u_int64_t offset;\r\n FILE *out;\r\n} ntwrk_struct_t;\r\n\r\nstatic size_t WriteMemoryCallback(void *contents, size_t size, size_t num_files, void *userp)\r\n{\r\n ntwrk_struct_t *data_struct = (ntwrk_struct_t *)userp;\r\n size_t realsize = size * num_files;\r\n\r\n if (realsize + data_struct->offset >= data_struct->data_size)\r\n {\r\n fwrite(data_struct->data, data_struct->offset, 1, data_struct->out);\r\n data_struct->offset = 0;\r\n }\r\n\r\n memcpy(&data_struct->data[data_struct->offset], contents, realsize);\r\n data_struct->offset += realsize;\r\n data_struct->data[data_struct->offset] = 0;\r\n return realsize;\r\n}\r\n\r\nint download_progress(void *p, double dltotal, double dlnow, double ultotal, double ulnow)\r\n{\r\n if (dltotal <= 0.0) return 0;\r\n\r\n struct timeval tv = {0};\r\n gettimeofday(&tv, NULL);\r\n int counter = round(tv.tv_usec / 100000);\r\n\r\n if (counter == 0 || counter == 2 || counter == 4 || counter == 6 || counter == 8)\r\n {\r\n printf(\"*** DOWNLOADING: %.2fMB of %.2fMB ***\\r\", dlnow / _1MiB, dltotal / _1MiB);\r\n consoleUpdate(NULL);\r\n }\r\n\r\n return 0;\r\n}\r\n\r\nbool downloadFile(const char *url, const char *output, int api)\r\n{\r\n CURL *curl = curl_easy_init();\r\n if (curl)\r\n {\r\n FILE *fp = fopen(output, \"wb\");\r\n if (fp)\r\n {\r\n printf(\"\\n\");\r\n\r\n ntwrk_struct_t chunk = {0};\r\n chunk.data = static_cast<u_int8_t *>(malloc(_1MiB));\r\n chunk.data_size = _1MiB;\r\n chunk.out = fp;\r\n\r\n curl_easy_setopt(curl, CURLOPT_URL, url);\r\n curl_easy_setopt(curl, CURLOPT_USERAGENT, API_AGENT);\r\n curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);\r\n curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);\r\n curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);\r\n\r\n // write calls\r\n curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);\r\n curl_easy_setopt(curl, CURLOPT_WRITEDATA, &chunk);\r\n\r\n if (api == OFF)\r\n {\r\n curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);\r\n curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, download_progress);\r\n }\r\n\r\n // execute curl, save result\r\n CURLcode res = curl_easy_perform(curl);\r\n\r\n // write from mem to file\r\n if (chunk.offset)\r\n fwrite(chunk.data, 1, chunk.offset, fp);\r\n\r\n // clean\r\n curl_easy_cleanup(curl);\r\n free(chunk.data);\r\n fclose(chunk.out);\r\n\r\n if (res == CURLE_OK)\r\n {\r\n std::cout << std::endl;\r\n consoleUpdate(NULL);\r\n return true;\r\n }\r\n }\r\n }\r\n consoleUpdate(NULL);\r\n return false;\r\n}\r\n\r\nstruct MemoryStruct {\r\n char *memory;\r\n size_t size;\r\n};\r\n\r\nstatic size_t WriteMemoryCallback2(void *contents, size_t size, size_t nmemb, void *userp)\r\n{\r\n size_t realsize = size * nmemb;\r\n struct MemoryStruct *mem = (struct MemoryStruct *)userp;\r\n \r\n char *ptr = static_cast<char *>(realloc(mem->memory, mem->size + realsize + 1));\r\n if(ptr == NULL) {\r\n /* out of memory! */ \r\n printf(\"not enough memory (realloc returned NULL)\\n\");\r\n return 0;\r\n }\r\n \r\n mem->memory = ptr;\r\n memcpy(&(mem->memory[mem->size]), contents, realsize);\r\n mem->size += realsize;\r\n mem->memory[mem->size] = 0;\r\n \r\n return realsize;\r\n}\r\n\r\n//1100 1300\r\nstd::string fetchVersion(const char *url, const char *range){\r\n CURL *curl_handle;\r\n CURLcode res;\r\n \r\n struct MemoryStruct chunk;\r\n \r\n chunk.memory = static_cast<char *>(malloc(1)); /* will be grown as needed by the realloc above */ \r\n chunk.size = 0; /* no data at this point */ \r\n \r\n curl_global_init(CURL_GLOBAL_ALL);\r\n \r\n /* init the curl session */ \r\n curl_handle = curl_easy_init();\r\n \r\n /* specify URL to get */ \r\n curl_easy_setopt(curl_handle, CURLOPT_URL, url);\r\n \r\n\r\n curl_easy_setopt(curl_handle, CURLOPT_RANGE, range);\r\n /* send all data to this function */ \r\n curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback2);\r\n \r\n /* we pass our 'chunk' struct to the callback function */ \r\n curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);\r\n \r\n /* some servers don't like requests that are made without a user-agent\r\n field, so we provide one */ \r\n curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, API_AGENT);\r\n\r\n curl_easy_setopt(curl_handle, CURLOPT_SSL_VERIFYPEER, 0L);\r\n \r\n /* get it! */ \r\n res = curl_easy_perform(curl_handle);\r\n \r\n /* check for errors */ \r\n std::string ver = \"-1\";\r\n if(res != CURLE_OK) {\r\n fprintf(stderr, \"curl_easy_perform() for page fetching failed: %s\\n\",\r\n curl_easy_strerror(res));\r\n }\r\n else {\r\n std::string s = std::string(chunk.memory);\r\n //std::cout << \"start html \" << s.substr(0, 199) << std::endl;\r\n std::regex rgx(\"<title>.+\");\r\n std::smatch match;\r\n if (std::regex_search(s, match, rgx)){\r\n //ver = std::stoi(match[0]);\r\n //std::cout << match[0].str().substr(match[0].str().find(\" \") + 1, 6) << std::endl;\r\n ver = match[0].str().substr(match[0].str().find(\" \") + 1, 5);\r\n }\r\n \r\n \r\n //printf(\"%lu bytes retrieved\\n\", (unsigned long)chunk.size);\r\n }\r\n \r\n /* cleanup curl stuff */ \r\n curl_easy_cleanup(curl_handle);\r\n \r\n free(chunk.memory);\r\n \r\n /* we're done with libcurl, so clean it up */ \r\n curl_global_cleanup();\r\n \r\n return ver;\r\n}\r\n\r\n"
},
{
"path": "source/extract.cpp",
"content": "#include \"extract.hpp\"\r\n\r\nstd::vector getInstalledTitles(std::vector storageId){\r\n std::vector titles;\r\n NcmContentMetaDatabase metadb;\r\n\r\n for (auto& sId : storageId){\r\n Result rc = ncmOpenContentMetaDatabase(&metadb, sId);\r\n if(R_SUCCEEDED(rc)){\r\n NcmApplicationContentMetaKey *recs = new NcmApplicationContentMetaKey[MaxTitleCount]();\r\n s32 wrt = 0;\r\n s32 total = 0;\r\n rc = ncmContentMetaDatabaseListApplication(&metadb, &total, &wrt, recs, MaxTitleCount, NcmContentMetaType_Application);\r\n if((R_SUCCEEDED(rc)) && (wrt > 0)){\r\n titles.reserve(wrt);\r\n for(s32 i = 0; i < wrt; i++){\r\n titles.push_back(formatApplicationId(recs[i].application_id));\r\n }\r\n }\r\n delete[] recs;\r\n serviceClose(&metadb.s);\r\n }\r\n }\r\n return titles;\r\n}\r\n\r\nstd::vector getInstalledTitlesNs(){\r\n // This function has been cobbled together from the \"app_controldata\" example in devkitpro.\r\n\r\n // Set the rc variable to begin with\r\n Result rc = 0;\r\n\r\n // Initialise a vector of tuples, storing the title ID and the title name.\r\n std::vector<Title> titles;\r\n\r\n // Initialise an application record array, where the size is MaxTitleCount\r\n NsApplicationRecord *recs = new NsApplicationRecord[MaxTitleCount]();\r\n\r\n // Set the buffer to NULL\r\n NsApplicationControlData *buf=NULL;\r\n // Set outsize to 0\r\n u64 outsize=0;\r\n // Set the language entry to NULL\r\n NacpLanguageEntry *langentry = NULL;\r\n\r\n // Create a char array to store the name of the title\r\n char name[0x201];\r\n\r\n // Set the total records to 0\r\n s32 total = 0;\r\n // Set a failed counter to 0\r\n int totalFailed = 0;\r\n // Fill the recs array with application records\r\n rc = nsListApplicationRecord(recs, MaxTitleCount, 0, &total);\r\n\r\n // If filling the recs array was successful\r\n if (R_SUCCEEDED(rc)){\r\n // Loop through records\r\n for (s32 i = 0; i < total; i++){\r\n\r\n // Reset varaibles for accessing memory\r\n outsize=0;\r\n buf = (NsApplicationControlData*)malloc(sizeof(NsApplicationControlData));\r\n if (buf==NULL) {\r\n rc = MAKERESULT(Module_Libnx, LibnxError_OutOfMemory);\r\n printf(\"Failed to alloc mem.\\n\");\r\n } else {\r\n memset(buf, 0, sizeof(NsApplicationControlData));\r\n }\r\n\r\n if (R_SUCCEEDED(rc)) {\r\n rc = nsInitialize();\r\n if (R_FAILED(rc)) {\r\n printf(\"nsInitialize() failed: 0x%x\\n\", rc);\r\n }\r\n }\r\n \r\n // Get the application control data for the current record\r\n rc = nsGetApplicationControlData(NsApplicationControlSource_Storage, recs[i].application_id, buf, sizeof(NsApplicationControlData), &outsize);\r\n\r\n if (R_FAILED(rc)) {\r\n totalFailed++;\r\n std::cout << \"nsGetApplicationControlData() failed: 0x\" << std::hex << rc << \" for Title ID: \" << formatApplicationId(recs[i].application_id) << std::endl;\r\n }\r\n\r\n if (outsize < sizeof(buf->nacp)) {\r\n rc = -1;\r\n printf(\"Outsize is too small: 0x%lx.\\n\", outsize);\r\n }\r\n\r\n // If application control data was retrieved successfully\r\n if (R_SUCCEEDED(rc)) {\r\n rc = nacpGetLanguageEntry(&buf->nacp, &langentry);\r\n\r\n if (R_FAILED(rc) || langentry==NULL) printf(\"Failed to load LanguageEntry.\\n\");\r\n }\r\n\r\n // If nacp language entry was retrieved successfully\r\n if (R_SUCCEEDED(rc)) {\r\n memset(name, 0, sizeof(name));\r\n strncpy(name, langentry->name, sizeof(name)-1); //Don't assume the nacp string is NUL-terminated for safety.\r\n titles.push_back({formatApplicationId(recs[i].application_id), name});\r\n }\r\n\r\n nsExit();\r\n }\r\n }\r\n\r\n free(buf);\r\n delete[] recs;\r\n std::sort(titles.begin(), titles.end());\r\n if(totalFailed > 0) \r\n std::cout << \"\\n\\nFailed \" << totalFailed << \" titles.\" << std::endl;\r\n return titles;\r\n}\r\n\r\nstd::string formatApplicationId(u64 ApplicationId){\r\n std::stringstream strm;\r\n strm << std::uppercase << std::setfill('0') << std::setw(16) << std::hex << ApplicationId;\r\n return strm.str();\r\n}\r\n\r\nstd::vector<Title> excludeTitles(const char* path, std::vector<Title> listedTitles){\r\n // Initialise a vector of titles\r\n std::vector<Title> titles;\r\n // Open a file stream\r\n std::ifstream file(path);\r\n // Declare a total variable and set to 0\r\n int total = 0;\r\n // Declare a name variable\r\n std::string name;\r\n\r\n\r\n if (file.is_open()) {\r\n std::string line;\r\n // Read each line of the file in\r\n while (std::getline(file, line)) {\r\n name = \"No name provided\";\r\n // Change the line to uppercase\r\n std::transform(line.begin(), line.end(), line.begin(), ::toupper);\r\n\r\n for(int i = 0; i < (int)listedTitles.size(); i++) {\r\n // Iterate through the listedTitles, and compare the id's in the file, to the installed title ids\r\n // When a match is found, it sets the name of the excluded title to the name of the installed title\r\n if(listedTitles.at(i).id == line) {\r\n name = listedTitles.at(i).name;\r\n break;\r\n }\r\n }\r\n // Push a new title to the titles vector and increment the total number of excluded titles\r\n titles.push_back({line, name});\r\n total++;\r\n }\r\n // Close the file\r\n file.close();\r\n }\r\n\r\n // Sort the titles list (uses an overloaded < operator to sort based on ID's)\r\n std::sort(titles.begin(), titles.end());\r\n\r\n if (total > 0)\r\n std::cout << \"Found \" << total << \" titles to exclude: \" << std::endl;\r\n\r\n printTitles(titles);\r\n\r\n std::cout << std::endl << std::endl;\r\n\r\n // Create a vector to store the difference between the excluded titles list, and the installed title list\r\n std::vector<Title> diff;\r\n // Populate the difference vector\r\n std::set_difference(listedTitles.begin(), listedTitles.end(), titles.begin(), titles.end(), \r\n std::inserter(diff, diff.begin()));\r\n return diff;\r\n}\r\n\r\nbool caselessCompare (const std::string& a, const std::string& b){\r\n return strcasecmp(a.c_str(), b.c_str()) < 0;\r\n}\r\n\r\nint extractCheats(std::string zipPath, std::vector<Title> titles, int cfw, bool credits){\r\n zipper::Unzipper unzipper(zipPath);\r\n std::vector<zipper::ZipEntry> entries = unzipper.entries();\r\n std::vector<Title> extractedTitles;\r\n int offset = 0;\r\n switch(cfw){\r\n case ams:\r\n offset = std::string(CONTENTS_PATH).length();\r\n chdir(AMS_PATH);\r\n break;\r\n case rnx:\r\n offset = std::string(CONTENTS_PATH).length();\r\n chdir(REINX_PATH);\r\n break;\r\n case sxos:\r\n offset = std::string(TITLES_PATH).length();\r\n chdir(SXOS_PATH);\r\n break;\r\n }\r\n\r\n std::vector<std::string> entriesNames;\r\n std::vector<int> parentIndexes;\r\n for (size_t i = 1; i < entries.size(); i++){\r\n entriesNames.push_back(entries[i].name);\r\n }\r\n\r\n std::sort(entriesNames.begin(), entriesNames.end(), caselessCompare);\r\n\r\n std::vector<std::string> parents;\r\n std::vector<std::vector<std::string>> children;\r\n std::vector<std::string> tempChildren;\r\n\r\n size_t k = 0;\r\n while(k < entriesNames.size()){\r\n if(entriesNames[k].length() == (size_t) (offset + 17)){\r\n parents.push_back(entriesNames[k]);\r\n k++;\r\n while(entriesNames[k].length() != (size_t) (offset + 17) && k < entriesNames.size()){\r\n if(credits == false){ \r\n if(strcasecmp(entriesNames[k].substr(offset + 16, 7).c_str(), \"/cheats\") == 0){\r\n tempChildren.push_back(entriesNames[k]);\r\n }\r\n }\r\n else{\r\n tempChildren.push_back(entriesNames[k]);\r\n }\r\n k++;\r\n }\r\n children.push_back(tempChildren);\r\n tempChildren.clear (); \r\n }\r\n else{\r\n k++;\r\n }\r\n }\r\n\r\n std::cout << \"\\033[1;4;31m\"<< \"\\n*** Extracting cheats (this may take a while) ***\" << \"\\033[0m\" <<std::endl;\r\n\r\n int count = 0;\r\n size_t lastL = 0;\r\n std::string name;\r\n std::string id;\r\n bool alreadyExtractedTitle;\r\n for(size_t j = 0; j < titles.size(); j++){\r\n for(size_t l = lastL; l < parents.size(); l++){\r\n if(strcasecmp((titles.at(j).id).c_str(), parents[l].substr(offset, 16).c_str()) == 0){\r\n unzipper.extractEntry(parents[l]);\r\n for(auto& e : children[l]){\r\n unzipper.extractEntry(e);\r\n std::cout << std::setfill(' ') << std::setw(80) << '\\r';\r\n\r\n name = \"No name retrieved.\";\r\n id = e.substr(offset, 16);\r\n std::transform(id.begin(), id.end(), id.begin(), ::toupper);\r\n\r\n for(int i = 0; i < (int)titles.size(); i++) {\r\n if(titles.at(i).id == id) {\r\n name = titles.at(i).name;\r\n break;\r\n }\r\n }\r\n\r\n alreadyExtractedTitle = false;\r\n for(int i = 0; i < (int)extractedTitles.size(); i++) {\r\n if(extractedTitles.at(i).id == id) {\r\n alreadyExtractedTitle = true;\r\n break;\r\n }\r\n }\r\n if(!alreadyExtractedTitle)\r\n extractedTitles.push_back({id, name});\r\n\r\n std::cout << e.substr(0, 79) << \"\\r\";\r\n count++;\r\n consoleUpdate(NULL);\r\n }\r\n lastL = l;\r\n break;\r\n }\r\n }\r\n }\r\n unzipper.close();\r\n\r\n std::cout << std::endl;\r\n std::cout << \"Successfully extracted \" \r\n << \"\\033[0;32m\" << count << \"\\033[0m\"\r\n << \" cheat files for \" \r\n << \"\\033[0;32m\" << extractedTitles.size() << \"\\033[0m\"\r\n << \" titles\" << std::endl;\r\n writeTitlesToFile(extractedTitles);\r\n return count;\r\n}\r\n\r\nint removeCheats(int cfw){\r\n std::string path;\r\n switch(cfw){\r\n case ams:\r\n path = std::string(AMS_PATH) + std::string(CONTENTS_PATH);\r\n std::filesystem::remove(std::string(CONFIG_PATH) + \"contents.zip\");\r\n break;\r\n case rnx:\r\n path = std::string(REINX_PATH) + std::string(CONTENTS_PATH);\r\n std::filesystem::remove(std::string(CONFIG_PATH) + \"contents.zip\");\r\n break;\r\n case sxos:\r\n path = std::string(SXOS_PATH) + std::string(TITLES_PATH);\r\n std::filesystem::remove(std::string(CONFIG_PATH) + \"titles.zip\");\r\n break;\r\n }\r\n int c = 0;\r\n for (const auto & entry : std::filesystem::directory_iterator(path)){\r\n std::string cheatsPath = entry.path().string() + \"/cheats\";\r\n if(std::filesystem::exists(cheatsPath)){\r\n for (const auto & cheat : std::filesystem::directory_iterator(cheatsPath)){\r\n std::filesystem::remove(cheat);\r\n c++;\r\n }\r\n //std::filesystem::remove(cheatsPath);\r\n rmdir(cheatsPath.c_str());\r\n if(std::filesystem::is_empty(entry)){\r\n rmdir(entry.path().string().c_str());\r\n }\r\n }\r\n }\r\n return c;\r\n}"
},
{
"path": "source/main.cpp",
"content": "#include <iostream>\r\n#include <tuple>\r\n#include <fstream>\r\n#include <filesystem>\r\n\r\n#include \"unzipper.h\"\r\n#include \"title.h\"\r\n#include <switch.h>\r\n\r\n#include \"extract.hpp\"\r\n#include \"download.hpp\"\r\n#include \"titles.hpp\"\r\n\r\n#define VERSION \"1.2.1\"\r\n#define RELEASE_URL \"https://github.com/HamletDuFromage/switch-cheats-db/releases/tag/v1.0\"\r\n#define ARCHIVE_URL \"https://github.com/HamletDuFromage/switch-cheats-db/releases/download/v1.0/\"\r\n\r\n#define WIDTH 80 // The width of the console\r\n#define HEIGHT 45 // Height of the console\r\n\r\n\r\nvoid initServices(){\r\n consoleInit(NULL);\r\n //ncmInitialize();\r\n nsInitialize();\r\n socketInitializeDefault();\r\n}\r\n\r\nvoid exitServices(){\r\n socketExit();\r\n nsExit();\r\n //ncmExit();\r\n consoleExit(NULL);\r\n}\r\n\r\nstd::string readVersion(std::string path){\r\n std::fstream versionFile;\r\n std::string version = \"0\";\r\n if(std::filesystem::exists(CONFIG_PATH + path)){\r\n versionFile.open(CONFIG_PATH + path, std::fstream::in);\r\n versionFile >> version;\r\n versionFile.close();\r\n }\r\n return version;\r\n}\r\n\r\nvoid saveVersion(std::string path, std::string version){\r\n std::fstream newVersion;\r\n newVersion.open(CONFIG_PATH + path, std::fstream::out | std::fstream::trunc);\r\n newVersion << version << std::endl;\r\n newVersion.close();\r\n}\r\n\r\nbool isServiceRunning(const char *serviceName) {\r\n Handle handle;\r\n SmServiceName service_name = smEncodeName(serviceName);\r\n bool running = R_FAILED(smRegisterService(&handle, service_name, false, 1));\r\n\r\n svcCloseHandle(handle);\r\n\r\n if (!running)\r\n smUnregisterService(service_name);\r\n\r\n return running;\r\n}\r\n\r\nCFW getCFW(){\r\n if(isServiceRunning(\"rnx\")) return rnx;\r\n else if(isServiceRunning(\"tx\")) return sxos;\r\n else return ams;\r\n}\r\n\r\nbool run(){ \r\n\r\n int cfw = getCFW();\r\n u64 kHeld = hidKeysHeld(CONTROLLER_P1_AUTO);\r\n bool credits = kHeld & KEY_L;\r\n std::string filename = \"\";\r\n switch(cfw){\r\n case ams:\r\n filename = \"contents.zip\";\r\n std::filesystem::create_directory(\"/atmosphere\");\r\n std::filesystem::create_directory(\"/atmosphere/contents\");\r\n break;\r\n case rnx:\r\n filename = \"contents.zip\";\r\n std::filesystem::create_directory(\"/ReiNX\");\r\n std::filesystem::create_directory(\"/ReiNX/contents\");\r\n break;\r\n case sxos:\r\n filename = \"titles.zip\";\r\n std::filesystem::create_directory(\"/sxos\");\r\n std::filesystem::create_directory(\"/sxos/titles\");\r\n break;\r\n }\r\n\r\n std::vector<Title> titles;\r\n\r\n titles = getInstalledTitlesNs();\r\n\r\n titles = excludeTitles((std::string(CONFIG_PATH) + \"exclude.txt\").c_str(), titles);\r\n\r\n //std::cout << std::endl;\r\n\r\n int total = titles.size();\r\n\r\n std::cout << \"\\033[0;32m\" << \"Found \" << total << \" installed titles\" << \"\\033[0m\" << std::endl << std::endl;\r\n\r\n consoleUpdate(NULL);\r\n\r\n std::string ver = fetchVersion(RELEASE_URL, \"1100-1110\");\r\n std::string oldVersion = readVersion(\"version.dat\");\r\n\r\n std::cout << \"Current cheats revision: v\" << \"\\033[31m\" << oldVersion << \"\\033[0m\" << \"\\nLatest cheats revision: v\" << \"\\033[0;32m\" << ver << \"\\033[0m\";\r\n switch(cfw){\r\n case ams : \r\n std::cout << \" for AMS\" << std::endl;\r\n break;\r\n case rnx : \r\n std::cout << \" for ReiNX\" << std::endl;\r\n break;\r\n case sxos :\r\n std::cout << \" for SXOS\" << std::endl;\r\n break;\r\n }\r\n std::cout << std::endl;\r\n\r\n if(ver == oldVersion){\r\n std::cout << \"Already up to date. There's nothing else to do.\" << std::endl;\r\n }\r\n else if(ver == \"-1\"){\r\n std::cout << \"Couldn't reach the download page. Please check your internet connection\" << std::endl;\r\n }\r\n else{\r\n std::cout << \"Downloading v\" << ver << \"...\" << std::endl;\r\n std::string url = std::string(ARCHIVE_URL) + filename;\r\n std::string path = std::string(CONFIG_PATH) + filename;\r\n if(downloadFile(url.c_str(), path.c_str(), OFF)){\r\n //if(false){\r\n extractCheats(path.c_str(), titles, cfw, credits);\r\n saveVersion(\"version.dat\", ver);\r\n }\r\n else{\r\n std::cout << \"Couldn't download the cheats archive\" << std::endl;\r\n }\r\n }\r\n consoleUpdate(NULL);\r\n\r\n // If the versions are the same, return false (indicating that the files were not updated)\r\n // Otherwise, return true (indicating that they were updated)\r\n if(ver == oldVersion) \r\n return false;\r\n else\r\n return true;\r\n}\r\n\r\nvoid cleanUp(){\r\n int cfw = getCFW();\r\n int c = removeCheats(cfw);\r\n saveVersion(\"version.dat\", \"0\");\r\n std::cout << \"Removed \" << c << \" cheat files\" << std::endl;\r\n}\r\n\r\nvoid viewTitles() {\r\n std::vector<Title> titles;\r\n\r\n titles = getInstalledTitlesNs();\r\n\r\n titles = excludeTitles((std::string(CONFIG_PATH) + \"exclude.txt\").c_str(), titles);\r\n //std::cout << std::endl;\r\n\r\n int total = titles.size();\r\n\r\n printTitles(titles);\r\n\r\n std::cout << std::endl << \"\\033[0;32m\" << \"Found \" << total << \" installed titles\" << \"\\033[0m\" << std::endl;\r\n \r\n std::cout << std::endl;\r\n \r\n}\r\n\r\nvoid viewHeader() {\r\n std::cout << \"\\033[31m\" << \"================================================================================\" << \"\\033[0m\" << std::endl;\r\n std::cout << \"\\033[1;31m\" << \"Cheats Updater v\" << VERSION << \" by HamletDuFromage & Acta\" << \"\\033[0m\" <<std::endl;\r\n std::cout << \"\\033[31m\" << \"================================================================================\" << \"\\033[0m\" << std::endl;\r\n std::cout << std::endl;\r\n consoleUpdate(NULL);\r\n}\r\nvoid viewMain() {\r\n viewHeader();\r\n\r\n std::cout << \"\\033[36m\" << \"Title IDs listed in \\\"/config/cheats-updater/exclude.txt\\\" won't get cheat updates\" << \"\\033[0m\" << std::endl;\r\n\r\n std::cout << \"Press [A] to download and update cheat files\" << std::endl;\r\n std::cout << \"Press [B] to view installed titles\" << std::endl;\r\n std::cout << \"Hold [L] and press [A] to also download cheat credits and instructions\" << std::endl;\r\n std::cout << \"Press [X] to delete ALL existing cheat files\\n\" << std::endl;\r\n\r\n std::cout << \"Press [+] to quit\" << std::endl << std::endl;\r\n\r\n consoleUpdate(NULL);\r\n}\r\n\r\nvoid clearConsole() {\r\n consoleClear();\r\n //consoleSetWindow(NULL, 0, 0, WIDTH, HEIGHT);\r\n consoleUpdate(NULL);\r\n}\r\n\r\nint main(int argc, char* argv[])\r\n{\r\n initServices();\r\n\r\n viewMain();\r\n\r\n std::filesystem::create_directory(\"/config\");\r\n std::filesystem::create_directory(CONFIG_PATH);\r\n\r\n bool done = false;\r\n bool updated = false;\r\n bool deleteCheatsConfirm = false;\r\n while (appletMainLoop())\r\n {\r\n hidScanInput();\r\n\r\n u64 kDown = hidKeysDown(CONTROLLER_P1_AUTO);\r\n\r\n if (kDown & KEY_A){\r\n if(!deleteCheatsConfirm) {\r\n if(!done) {\r\n clearConsole();\r\n viewHeader();\r\n updated = run();\r\n done = true;\r\n\r\n if(updated) {\r\n std::cout << \"\\nPress [Y] to view updated files.\\n\" << std::endl;\r\n }\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [-] to return to main menu\" << \"\\033[0m\" <<std::endl;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [+] to quit\" << \"\\033[0m\" <<std::endl;\r\n consoleUpdate(NULL);\r\n\r\n }\r\n } else {\r\n clearConsole();\r\n viewHeader();\r\n cleanUp();\r\n updated = false;\r\n done = true;\r\n deleteCheatsConfirm = false;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [-] to return to main menu\" << \"\\033[0m\" <<std::endl;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [+] to quit\" << \"\\033[0m\" <<std::endl;\r\n consoleUpdate(NULL);\r\n }\r\n \r\n } \r\n\r\n if (kDown & KEY_X){\r\n if(!done) {\r\n deleteCheatsConfirm = true;\r\n clearConsole();\r\n viewHeader();\r\n std::cout << \"\\033[1;31m\" << \"Are you sure? this will delete every cheat from your /titles/ folder.\" << std::endl;\r\n std::cout << \"Press [A] to delete ALL existing cheat files\" << std::endl;\r\n std::cout << \"Press [-] to return to main menu and abort\" << \"\\033[0m\" <<std::endl;\r\n done = true;\r\n consoleUpdate(NULL);\r\n }\r\n }\r\n\r\n if (kDown & KEY_B){\r\n if(!done){\r\n clearConsole();\r\n viewHeader();\r\n viewTitles();\r\n updated = false;\r\n done = true;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [-] to return to main menu\" << \"\\033[0m\" <<std::endl;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [+] to quit\" << \"\\033[0m\" <<std::endl;\r\n consoleUpdate(NULL);\r\n\r\n }\r\n }\r\n\r\n if (kDown & KEY_MINUS) {\r\n if(done) {\r\n clearConsole();\r\n viewMain();\r\n updated = false;\r\n done = false;\r\n deleteCheatsConfirm = false;\r\n consoleUpdate(NULL);\r\n }\r\n }\r\n if (kDown & KEY_Y) {\r\n if(updated) {\r\n clearConsole();\r\n viewHeader();\r\n outputUpdatedTitles();\r\n consoleUpdate(NULL);\r\n updated = false;\r\n }\r\n }\r\n\r\n if (kDown & KEY_PLUS)\r\n break; \r\n }\r\n\r\n exitServices();\r\n return 0;\r\n}\r\n"
},
{
"path": "source/titles.cpp",
"content": "#include \"titles.hpp\"\r\n\r\n\r\n/**\r\n * writeTitlesToFile\r\n * Writes the input vector to the updated.dat file in config\r\n * Stores the id and name of each title seprated by a comma\r\n**/\r\nvoid writeTitlesToFile(std::vector<Title> titles) {\r\n std::ofstream updatedTitlesFile;\r\n updatedTitlesFile.open(UPDATED_TITLES_PATH, std::ofstream::out | std::ofstream::trunc);\r\n if(updatedTitlesFile.is_open()) {\r\n for(int t = 0; t < (int)titles.size(); t++) {\r\n updatedTitlesFile << titles.at(t).id << \",\" << titles.at(t).name << std::endl;\r\n }\r\n updatedTitlesFile.close();\r\n }\r\n}\r\n\r\n/**\r\n * readTitlesFromFile\r\n * Reads titles from the updated.dat file in config\r\n * Stores them as a new titles vector, and returns this to the function calling.\r\n**/\r\nstd::vector<Title> readTitlesFromFile() {\r\n std::ifstream updatedTitlesFile;\r\n updatedTitlesFile.open(UPDATED_TITLES_PATH);\r\n\r\n std::string name;\r\n std::string id;\r\n std::string line;\r\n\r\n std::vector<Title> titles;\r\n\r\n if(updatedTitlesFile.is_open()) {\r\n while(getline(updatedTitlesFile, line)) {\r\n id = line.substr(0, 16);\r\n name = line.substr(17, line.size());\r\n titles.push_back({id, name});\r\n }\r\n updatedTitlesFile.close();\r\n }\r\n return titles;\r\n}\r\n\r\n/**\r\n * outputUpdatedTitles\r\n * Displays the contents of the updated.dat file in /config/\r\n**/\r\nvoid outputUpdatedTitles() {\r\n std::vector<Title> titles = readTitlesFromFile();\r\n \r\n std::cout << \"Updated Titles:\" << std::endl;\r\n\r\n printTitles(titles);\r\n\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [-] to return to main menu\" << \"\\033[0m\" <<std::endl;\r\n std::cout << \"\\033[7;37m\"<< \"\\nPress [+] to quit\" << \"\\033[0m\" <<std::endl;\r\n}\r\n\r\n/**\r\n * printTitles\r\n * Display the titles vector parsed in\r\n * Truncates the name of the titles when necessary\r\n */ \r\nvoid printTitles(std::vector<Title> titles) {\r\n for(int i = 0; i < (int)titles.size(); i++) {\r\n if(titles.at(i).name.size() > 35) {\r\n titles.at(i).name = titles.at(i).name.substr(0, 35);\r\n titles.at(i).name.append(\"...\");\r\n }\r\n std::cout << \"\\033[1;37m\" << \"Title ID: \" << \"\\033[0m\" << titles.at(i).id << \"\\033[1;37m\" << \" Title Name: \" << \"\\033[0m\" << titles.at(i).name << std::endl;\r\n consoleUpdate(NULL);\r\n }\r\n}"
}
]