From b230cf3aa24f3883b8b165bd5fd56620a9a95e47 Mon Sep 17 00:00:00 2001 From: Dominik Riebeling Date: Sun, 8 Mar 2015 19:07:42 +0100 Subject: Update quazip to release 0.7.1. Update to latest quazip release. Note that quazip is now LGPL and not GPL / LGPL dual licensed anymore. Change-Id: Ie1e975b5b546dd31218eef9df472527493fe81e0 --- rbutil/rbutilqt/quazip/LICENSE.GPL | 341 ----- rbutil/rbutilqt/quazip/LICENSE.LGPL | 458 +++++++ rbutil/rbutilqt/quazip/README.ROCKBOX | 9 +- rbutil/rbutilqt/quazip/crypt.h | 12 +- rbutil/rbutilqt/quazip/ioapi.c | 184 --- rbutil/rbutilqt/quazip/ioapi.h | 190 ++- rbutil/rbutilqt/quazip/qioapi.cpp | 361 ++++++ rbutil/rbutilqt/quazip/quazip.cpp | 723 +++++++++-- rbutil/rbutilqt/quazip/quazip.h | 377 ++++-- rbutil/rbutilqt/quazip/quazip_global.h | 59 + rbutil/rbutilqt/quazip/quazipfile.cpp | 385 ++++-- rbutil/rbutilqt/quazip/quazipfile.h | 114 +- rbutil/rbutilqt/quazip/quazipfileinfo.cpp | 176 +++ rbutil/rbutilqt/quazip/quazipfileinfo.h | 157 ++- rbutil/rbutilqt/quazip/quazipnewinfo.cpp | 284 ++++- rbutil/rbutilqt/quazip/quazipnewinfo.h | 152 ++- rbutil/rbutilqt/quazip/unzip.c | 1344 ++++++++++++++------ rbutil/rbutilqt/quazip/unzip.h | 154 ++- rbutil/rbutilqt/quazip/zip.c | 1950 +++++++++++++++++++++-------- rbutil/rbutilqt/quazip/zip.h | 211 +++- rbutil/rbutilqt/rbutilqt.pri | 5 +- rbutil/rbutilqt/rbutilqt.pro | 2 +- 22 files changed, 5650 insertions(+), 1998 deletions(-) delete mode 100644 rbutil/rbutilqt/quazip/LICENSE.GPL create mode 100644 rbutil/rbutilqt/quazip/LICENSE.LGPL delete mode 100644 rbutil/rbutilqt/quazip/ioapi.c create mode 100644 rbutil/rbutilqt/quazip/qioapi.cpp create mode 100644 rbutil/rbutilqt/quazip/quazip_global.h create mode 100644 rbutil/rbutilqt/quazip/quazipfileinfo.cpp (limited to 'rbutil') diff --git a/rbutil/rbutilqt/quazip/LICENSE.GPL b/rbutil/rbutilqt/quazip/LICENSE.GPL deleted file mode 100644 index 04a7580109..0000000000 --- a/rbutil/rbutilqt/quazip/LICENSE.GPL +++ /dev/null @@ -1,341 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 2, June 1991 - - Copyright (C) 1989, 1991 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -License is intended to guarantee your freedom to share and change free -software--to make sure the software is free for all its users. This -General Public License applies to most of the Free Software -Foundation's software and to any other program whose authors commit to -using it. (Some other Free Software Foundation software is covered by -the GNU Library General Public License instead.) You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -this service if you wish), that you receive source code or can get it -if you want it, that you can change the software or use pieces of it -in new free programs; and that you know you can do these things. - - To protect your rights, we need to make restrictions that forbid -anyone to deny you these rights or to ask you to surrender the rights. -These restrictions translate to certain responsibilities for you if you -distribute copies of the software, or if you modify it. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must give the recipients all the rights that -you have. You must make sure that they, too, receive or can get the -source code. And you must show them these terms so they know their -rights. - - We protect your rights with two steps: (1) copyright the software, and -(2) offer you this license which gives you legal permission to copy, -distribute and/or modify the software. - - Also, for each author's protection and ours, we want to make certain -that everyone understands that there is no warranty for this free -software. If the software is modified by someone else and passed on, we -want its recipients to know that what they have is not the original, so -that any problems introduced by others will not reflect on the original -authors' reputations. - - Finally, any free program is threatened constantly by software -patents. We wish to avoid the danger that redistributors of a free -program will individually obtain patent licenses, in effect making the -program proprietary. To prevent this, we have made it clear that any -patent must be licensed for everyone's free use or not licensed at all. - - The precise terms and conditions for copying, distribution and -modification follow. - - GNU GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License applies to any program or other work which contains -a notice placed by the copyright holder saying it may be distributed -under the terms of this General Public License. The "Program", below, -refers to any such program or work, and a "work based on the Program" -means either the Program or any derivative work under copyright law: -that is to say, a work containing the Program or a portion of it, -either verbatim or with modifications and/or translated into another -language. (Hereinafter, translation is included without limitation in -the term "modification".) Each licensee is addressed as "you". - -Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running the Program is not restricted, and the output from the Program -is covered only if its contents constitute a work based on the -Program (independent of having been made by running the Program). -Whether that is true depends on what the Program does. - - 1. You may copy and distribute verbatim copies of the Program's -source code as you receive it, in any medium, provided that you -conspicuously and appropriately publish on each copy an appropriate -copyright notice and disclaimer of warranty; keep intact all the -notices that refer to this License and to the absence of any warranty; -and give any other recipients of the Program a copy of this License -along with the Program. - -You may charge a fee for the physical act of transferring a copy, and -you may at your option offer warranty protection in exchange for a fee. - - 2. You may modify your copy or copies of the Program or any portion -of it, thus forming a work based on the Program, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) You must cause the modified files to carry prominent notices - stating that you changed the files and the date of any change. - - b) You must cause any work that you distribute or publish, that in - whole or in part contains or is derived from the Program or any - part thereof, to be licensed as a whole at no charge to all third - parties under the terms of this License. - - c) If the modified program normally reads commands interactively - when run, you must cause it, when started running for such - interactive use in the most ordinary way, to print or display an - announcement including an appropriate copyright notice and a - notice that there is no warranty (or else, saying that you provide - a warranty) and that users may redistribute the program under - these conditions, and telling the user how to view a copy of this - License. (Exception: if the Program itself is interactive but - does not normally print such an announcement, your work based on - the Program is not required to print an announcement.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Program, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Program, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Program. - -In addition, mere aggregation of another work not based on the Program -with the Program (or with a work based on the Program) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may copy and distribute the Program (or a work based on it, -under Section 2) in object code or executable form under the terms of -Sections 1 and 2 above provided that you also do one of the following: - - a) Accompany it with the complete corresponding machine-readable - source code, which must be distributed under the terms of Sections - 1 and 2 above on a medium customarily used for software interchange; or, - - b) Accompany it with a written offer, valid for at least three - years, to give any third party, for a charge no more than your - cost of physically performing source distribution, a complete - machine-readable copy of the corresponding source code, to be - distributed under the terms of Sections 1 and 2 above on a medium - customarily used for software interchange; or, - - c) Accompany it with the information you received as to the offer - to distribute corresponding source code. (This alternative is - allowed only for noncommercial distribution and only if you - received the program in object code or executable form with such - an offer, in accord with Subsection b above.) - -The source code for a work means the preferred form of the work for -making modifications to it. For an executable work, complete source -code means all the source code for all modules it contains, plus any -associated interface definition files, plus the scripts used to -control compilation and installation of the executable. However, as a -special exception, the source code distributed need not include -anything that is normally distributed (in either source or binary -form) with the major components (compiler, kernel, and so on) of the -operating system on which the executable runs, unless that component -itself accompanies the executable. - -If distribution of executable or object code is made by offering -access to copy from a designated place, then offering equivalent -access to copy the source code from the same place counts as -distribution of the source code, even though third parties are not -compelled to copy the source along with the object code. - - 4. You may not copy, modify, sublicense, or distribute the Program -except as expressly provided under this License. Any attempt -otherwise to copy, modify, sublicense or distribute the Program is -void, and will automatically terminate your rights under this License. -However, parties who have received copies, or rights, from you under -this License will not have their licenses terminated so long as such -parties remain in full compliance. - - 5. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Program or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Program (or any work based on the -Program), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Program or works based on it. - - 6. Each time you redistribute the Program (or any work based on the -Program), the recipient automatically receives a license from the -original licensor to copy, distribute or modify the Program subject to -these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties to -this License. - - 7. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Program at all. For example, if a patent -license would not permit royalty-free redistribution of the Program by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Program. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system, which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 8. If the distribution and/or use of the Program is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Program under this License -may add an explicit geographical distribution limitation excluding -those countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 9. The Free Software Foundation may publish revised and/or new versions -of the General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - -Each version is given a distinguishing version number. If the Program -specifies a version number of this License which applies to it and "any -later version", you have the option of following the terms and conditions -either of that version or of any later version published by the Free -Software Foundation. If the Program does not specify a version number of -this License, you may choose any version ever published by the Free Software -Foundation. - - 10. If you wish to incorporate parts of the Program into other free -programs whose distribution conditions are different, write to the author -to ask for permission. For software which is copyrighted by the Free -Software Foundation, write to the Free Software Foundation; we sometimes -make exceptions for this. Our decision will be guided by the two goals -of preserving the free status of all derivatives of our free software and -of promoting the sharing and reuse of software generally. - - NO WARRANTY - - 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY -FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN -OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES -PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED -OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS -TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE -PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, -REPAIR OR CORRECTION. - - 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR -REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, -INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING -OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED -TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY -YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER -PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE -POSSIBILITY OF SUCH DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -convey the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. - -Also add information on how to contact you by electronic and paper mail. - -If the program is interactive, make it output a short notice like this -when it starts in an interactive mode: - - Gnomovision version 69, Copyright (C) year name of author - Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, the commands you use may -be called something other than `show w' and `show c'; they could even be -mouse-clicks or menu items--whatever suits your program. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the program, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the program - `Gnomovision' (which makes passes at compilers) written by James Hacker. - - , 1 April 1989 - Ty Coon, President of Vice - -This General Public License does not permit incorporating your program into -proprietary programs. If your program is a subroutine library, you may -consider it more useful to permit linking proprietary applications with the -library. If this is what you want to do, use the GNU Library General -Public License instead of this License. - -------------------------------------------------------------------------- diff --git a/rbutil/rbutilqt/quazip/LICENSE.LGPL b/rbutil/rbutilqt/quazip/LICENSE.LGPL new file mode 100644 index 0000000000..2cba2ac74c --- /dev/null +++ b/rbutil/rbutilqt/quazip/LICENSE.LGPL @@ -0,0 +1,458 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS diff --git a/rbutil/rbutilqt/quazip/README.ROCKBOX b/rbutil/rbutilqt/quazip/README.ROCKBOX index b95f80caee..b4ffc270ae 100644 --- a/rbutil/rbutilqt/quazip/README.ROCKBOX +++ b/rbutil/rbutilqt/quazip/README.ROCKBOX @@ -1,6 +1,9 @@ This folder contains the quazip project for ZIP file compression/decompression. -These files are distributed under the GPL v2 or later. -The source files have been last synced with the projects release at -http://sourceforge.net/projects/quazip/ on July 20, 2010 +These files are distributed under the LGPL v2.1 or later. Only source files +actually used in Rockbox Utility are included, further sources have been left +out. Check the quazip source distribution for those. + +The source files have been last synced with the projects release 0.7.1 at +http://sourceforge.net/projects/quazip/ on March 8, 2015. diff --git a/rbutil/rbutilqt/quazip/crypt.h b/rbutil/rbutilqt/quazip/crypt.h index 359cf6726e..ddee28e7dd 100644 --- a/rbutil/rbutilqt/quazip/crypt.h +++ b/rbutil/rbutilqt/quazip/crypt.h @@ -27,17 +27,19 @@ Encryption is not supported. */ +#include "quazip_global.h" + #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) /*********************************************************************** * Return the next byte in the pseudo-random sequence */ -static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) +static int decrypt_byte(unsigned long* pkeys, const z_crc_t FAR * pcrc_32_tab UNUSED) { + //(void) pcrc_32_tab; /* avoid "unused parameter" warning */ unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an * unpredictable manner on 16-bit systems; not a problem * with any known compiler so far, though */ - (void) pcrc_32_tab; /* avoid "unused parameter" warning */ temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); @@ -46,7 +48,7 @@ static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) /*********************************************************************** * Update the encryption keys with the next byte of plain text */ -static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) +static int update_keys(unsigned long* pkeys,const z_crc_t FAR * pcrc_32_tab,int c) { (*(pkeys+0)) = CRC32((*(pkeys+0)), c); (*(pkeys+1)) += (*(pkeys+0)) & 0xff; @@ -63,7 +65,7 @@ static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int * Initialize the encryption keys and the random header according to * the given password. */ -static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) +static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t FAR * pcrc_32_tab) { *(pkeys+0) = 305419896L; *(pkeys+1) = 591751049L; @@ -93,7 +95,7 @@ static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) unsigned char *buf; /* where to write header */ int bufSize; unsigned long* pkeys; - const unsigned long* pcrc_32_tab; + const z_crc_t FAR * pcrc_32_tab; unsigned long crcForCrypting; { int n; /* index in random header */ diff --git a/rbutil/rbutilqt/quazip/ioapi.c b/rbutil/rbutilqt/quazip/ioapi.c deleted file mode 100644 index c43144006c..0000000000 --- a/rbutil/rbutilqt/quazip/ioapi.c +++ /dev/null @@ -1,184 +0,0 @@ -/* ioapi.c -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API - - Version 1.01e, February 12th, 2005 - - Copyright (C) 1998-2005 Gilles Vollant -*/ - -#include -#include -#include - -#include "zlib.h" -#include "ioapi.h" - - - -/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ - -#ifndef SEEK_CUR -#define SEEK_CUR 1 -#endif - -#ifndef SEEK_END -#define SEEK_END 2 -#endif - -#ifndef SEEK_SET -#define SEEK_SET 0 -#endif - -voidpf ZCALLBACK fopen_file_func OF(( - voidpf opaque, - const char* filename, - int mode)); - -uLong ZCALLBACK fread_file_func OF(( - voidpf opaque, - voidpf stream, - void* buf, - uLong size)); - -uLong ZCALLBACK fwrite_file_func OF(( - voidpf opaque, - voidpf stream, - const void* buf, - uLong size)); - -long ZCALLBACK ftell_file_func OF(( - voidpf opaque, - voidpf stream)); - -long ZCALLBACK fseek_file_func OF(( - voidpf opaque, - voidpf stream, - uLong offset, - int origin)); - -int ZCALLBACK fclose_file_func OF(( - voidpf opaque, - voidpf stream)); - -int ZCALLBACK ferror_file_func OF(( - voidpf opaque, - voidpf stream)); - - -voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) - voidpf opaque; - const char* filename; - int mode; -{ - FILE* file = NULL; - const char* mode_fopen = NULL; - (void) opaque; /* avoid "unused parameter" warning */ - if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) - mode_fopen = "rb"; - else - if (mode & ZLIB_FILEFUNC_MODE_EXISTING) - mode_fopen = "r+b"; - else - if (mode & ZLIB_FILEFUNC_MODE_CREATE) - mode_fopen = "wb"; - - if ((filename!=NULL) && (mode_fopen != NULL)) - file = fopen(filename, mode_fopen); - return file; -} - - -uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - void* buf; - uLong size; -{ - uLong ret; - (void) opaque; /* avoid "unused parameter" warning */ - ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); - return ret; -} - - -uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - const void* buf; - uLong size; -{ - uLong ret; - (void) opaque; /* avoid "unused parameter" warning */ - ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); - return ret; -} - -long ZCALLBACK ftell_file_func (opaque, stream) - voidpf opaque; - voidpf stream; -{ - long ret; - (void) opaque; /* avoid "unused parameter" warning */ - ret = ftell((FILE *)stream); - return ret; -} - -long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) - voidpf opaque; - voidpf stream; - uLong offset; - int origin; -{ - int fseek_origin=0; - long ret; - (void) opaque; /* avoid "unused parameter" warning */ - switch (origin) - { - case ZLIB_FILEFUNC_SEEK_CUR : - fseek_origin = SEEK_CUR; - break; - case ZLIB_FILEFUNC_SEEK_END : - fseek_origin = SEEK_END; - break; - case ZLIB_FILEFUNC_SEEK_SET : - fseek_origin = SEEK_SET; - break; - default: return -1; - } - ret = 0; - fseek((FILE *)stream, offset, fseek_origin); - return ret; -} - -int ZCALLBACK fclose_file_func (opaque, stream) - voidpf opaque; - voidpf stream; -{ - int ret; - (void) opaque; /* avoid "unused parameter" warning */ - ret = fclose((FILE *)stream); - return ret; -} - -int ZCALLBACK ferror_file_func (opaque, stream) - voidpf opaque; - voidpf stream; -{ - int ret; - (void) opaque; /* avoid "unused parameter" warning */ - ret = ferror((FILE *)stream); - return ret; -} - -void fill_fopen_filefunc (pzlib_filefunc_def) - zlib_filefunc_def* pzlib_filefunc_def; -{ - pzlib_filefunc_def->zopen_file = fopen_file_func; - pzlib_filefunc_def->zread_file = fread_file_func; - pzlib_filefunc_def->zwrite_file = fwrite_file_func; - pzlib_filefunc_def->ztell_file = ftell_file_func; - pzlib_filefunc_def->zseek_file = fseek_file_func; - pzlib_filefunc_def->zclose_file = fclose_file_func; - pzlib_filefunc_def->zerror_file = ferror_file_func; - pzlib_filefunc_def->opaque = NULL; -} diff --git a/rbutil/rbutilqt/quazip/ioapi.h b/rbutil/rbutilqt/quazip/ioapi.h index 7d457baab3..bbb94c8c76 100644 --- a/rbutil/rbutilqt/quazip/ioapi.h +++ b/rbutil/rbutilqt/quazip/ioapi.h @@ -1,14 +1,110 @@ /* ioapi.h -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API + part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) - Version 1.01e, February 12th, 2005 + Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) + + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) + + Modified by Sergey A. Tachenov to allow QIODevice API usage. + + For more info read MiniZip_info.txt + + Changes + + Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this) + Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux. + More if/def section may be needed to support other platforms + Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows. + (but you should use iowin32.c for windows instead) - Copyright (C) 1998-2005 Gilles Vollant */ -#ifndef _ZLIBIOAPI_H -#define _ZLIBIOAPI_H +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H + +#if (!defined(_WIN32)) && (!defined(WIN32)) + + // Linux needs this to support file operation on files larger then 4+GB + // But might need better if/def to select just the platforms that needs them. + + #ifndef __USE_FILE_OFFSET64 + #define __USE_FILE_OFFSET64 + #endif + #ifndef __USE_LARGEFILE64 + #define __USE_LARGEFILE64 + #endif + #ifndef _LARGEFILE64_SOURCE + #define _LARGEFILE64_SOURCE + #endif + #ifndef _FILE_OFFSET_BIT + #define _FILE_OFFSET_BIT 64 + #endif +#endif + +#include +#include +#include "zlib.h" + +#if defined(USE_FILE32API) +#define fopen64 fopen +#define ftello64 ftell +#define fseeko64 fseek +#else +#ifdef _MSC_VER + #define fopen64 fopen + #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) + #define ftello64 _ftelli64 + #define fseeko64 _fseeki64 + #else // old MSC + #define ftello64 ftell + #define fseeko64 fseek + #endif +#endif +#endif + +/* +#ifndef ZPOS64_T + #ifdef _WIN32 + #define ZPOS64_T fpos_t + #else + #include + #define ZPOS64_T uint64_t + #endif +#endif +*/ + +#ifdef HAVE_MINIZIP64_CONF_H +#include "mz64conf.h" +#endif + +/* a type choosen by DEFINE */ +#ifdef HAVE_64BIT_INT_CUSTOM +typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T; +#else +#ifdef HAS_STDINT_H +#include "stdint.h" +typedef uint64_t ZPOS64_T; +#else + + +#if defined(_MSC_VER) || defined(__BORLANDC__) +typedef unsigned __int64 ZPOS64_T; +#else +typedef unsigned long long int ZPOS64_T; +#endif +#endif +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef OF +#define OF _Z_OF +#endif #define ZLIB_FILEFUNC_SEEK_CUR (1) #define ZLIB_FILEFUNC_SEEK_END (2) @@ -23,26 +119,27 @@ #ifndef ZCALLBACK - -#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) -#define ZCALLBACK CALLBACK -#else -#define ZCALLBACK -#endif + #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) + #define ZCALLBACK CALLBACK + #else + #define ZCALLBACK + #endif #endif -#ifdef __cplusplus -extern "C" { -#endif -typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); -typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); -typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); -typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); -typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); -typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); -typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, voidpf file, int mode)); +typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); +typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); +typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); + +typedef uLong (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); + + +/* here is the "old" 32 bits structure structure */ typedef struct zlib_filefunc_def_s { open_file_func zopen_file; @@ -55,21 +152,56 @@ typedef struct zlib_filefunc_def_s voidpf opaque; } zlib_filefunc_def; +typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream)); +typedef int (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)); +typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, voidpf file, int mode)); +typedef struct zlib_filefunc64_def_s +{ + open64_file_func zopen64_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell64_file_func ztell64_file; + seek64_file_func zseek64_file; + close_file_func zclose_file; + testerror_file_func zerror_file; + voidpf opaque; + close_file_func zfakeclose_file; // for no-auto-close flag +} zlib_filefunc64_def; -void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); +void fill_qiodevice64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def)); +void fill_qiodevice_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); -#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) -#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) -#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) -#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) -#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) -#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) +/* now internal definition, only for zip.c and unzip.h */ +typedef struct zlib_filefunc64_32_def_s +{ + zlib_filefunc64_def zfile_func64; + open_file_func zopen32_file; + tell_file_func ztell32_file; + seek_file_func zseek32_file; +} zlib_filefunc64_32_def; + + +#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream)) +//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode)) +#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZFAKECLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zfakeclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream)) +voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf file,int mode)); +int call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)); +ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)); + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32); + +#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) +#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) +#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) #ifdef __cplusplus } #endif #endif - diff --git a/rbutil/rbutilqt/quazip/qioapi.cpp b/rbutil/rbutilqt/quazip/qioapi.cpp new file mode 100644 index 0000000000..534dbdf51f --- /dev/null +++ b/rbutil/rbutilqt/quazip/qioapi.cpp @@ -0,0 +1,361 @@ +/* ioapi.c -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + Version 1.01e, February 12th, 2005 + + Copyright (C) 1998-2005 Gilles Vollant + + Modified by Sergey A. Tachenov to integrate with Qt. +*/ + +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" +#include "quazip_global.h" +#include +#if (QT_VERSION >= 0x050100) +#define QUAZIP_QSAVEFILE_BUG_WORKAROUND +#endif +#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND +#include +#endif + +/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ + +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif + +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,voidpf file,int mode) +{ + if (pfilefunc->zfile_func64.zopen64_file != NULL) + return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,file,mode); + else + { + return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,file,mode); + } +} + +int call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin) +{ + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin); + else + { + uLong offsetTruncated = (uLong)offset; + if (offsetTruncated != offset) + return -1; + else + return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin); + } +} + +ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream) +{ + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream); + else + { + uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream); + if ((tell_uLong) == ((uLong)-1)) + return (ZPOS64_T)-1; + else + return tell_uLong; + } +} + +struct QIODevice_descriptor { + // Position only used for writing to sequential devices. + qint64 pos; + inline QIODevice_descriptor(): + pos(0) + {} +}; + +voidpf ZCALLBACK qiodevice_open_file_func ( + voidpf opaque, + voidpf file, + int mode) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + QIODevice *iodevice = reinterpret_cast(file); + QIODevice::OpenMode desiredMode; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) + desiredMode = QIODevice::ReadOnly; + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + desiredMode = QIODevice::ReadWrite; + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + desiredMode = QIODevice::WriteOnly; + if (iodevice->isOpen()) { + if ((iodevice->openMode() & desiredMode) == desiredMode) { + if (desiredMode != QIODevice::WriteOnly + && iodevice->isSequential()) { + // We can use sequential devices only for writing. + delete d; + return NULL; + } else { + if ((desiredMode & QIODevice::WriteOnly) != 0) { + // open for writing, need to seek existing device + if (!iodevice->isSequential()) { + iodevice->seek(0); + } else { + d->pos = iodevice->pos(); + } + } + } + return iodevice; + } else { + delete d; + return NULL; + } + } + iodevice->open(desiredMode); + if (iodevice->isOpen()) { + if (desiredMode != QIODevice::WriteOnly && iodevice->isSequential()) { + // We can use sequential devices only for writing. + iodevice->close(); + delete d; + return NULL; + } else { + return iodevice; + } + } else { + delete d; + return NULL; + } +} + + +uLong ZCALLBACK qiodevice_read_file_func ( + voidpf opaque, + voidpf stream, + void* buf, + uLong size) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + QIODevice *iodevice = reinterpret_cast(stream); + qint64 ret64 = iodevice->read((char*)buf,size); + uLong ret; + ret = (uLong) ret64; + if (ret64 != -1) { + d->pos += ret64; + } + return ret; +} + + +uLong ZCALLBACK qiodevice_write_file_func ( + voidpf opaque, + voidpf stream, + const void* buf, + uLong size) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + QIODevice *iodevice = reinterpret_cast(stream); + uLong ret; + qint64 ret64 = iodevice->write((char*)buf,size); + if (ret64 != -1) { + d->pos += ret64; + } + ret = (uLong) ret64; + return ret; +} + +uLong ZCALLBACK qiodevice_tell_file_func ( + voidpf opaque, + voidpf stream) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + QIODevice *iodevice = reinterpret_cast(stream); + uLong ret; + qint64 ret64; + if (iodevice->isSequential()) { + ret64 = d->pos; + } else { + ret64 = iodevice->pos(); + } + ret = static_cast(ret64); + return ret; +} + +ZPOS64_T ZCALLBACK qiodevice64_tell_file_func ( + voidpf opaque, + voidpf stream) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + QIODevice *iodevice = reinterpret_cast(stream); + qint64 ret; + if (iodevice->isSequential()) { + ret = d->pos; + } else { + ret = iodevice->pos(); + } + return static_cast(ret); +} + +int ZCALLBACK qiodevice_seek_file_func ( + voidpf /*opaque UNUSED*/, + voidpf stream, + uLong offset, + int origin) +{ + QIODevice *iodevice = reinterpret_cast(stream); + if (iodevice->isSequential()) { + if (origin == ZLIB_FILEFUNC_SEEK_END + && offset == 0) { + // sequential devices are always at end (needed in mdAppend) + return 0; + } else { + qWarning("qiodevice_seek_file_func() called for sequential device"); + return -1; + } + } + uLong qiodevice_seek_result=0; + int ret; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset; + break; + case ZLIB_FILEFUNC_SEEK_END : + qiodevice_seek_result = ((QIODevice*)stream)->size() - offset; + break; + case ZLIB_FILEFUNC_SEEK_SET : + qiodevice_seek_result = offset; + break; + default: + return -1; + } + ret = !iodevice->seek(qiodevice_seek_result); + return ret; +} + +int ZCALLBACK qiodevice64_seek_file_func ( + voidpf /*opaque UNUSED*/, + voidpf stream, + ZPOS64_T offset, + int origin) +{ + QIODevice *iodevice = reinterpret_cast(stream); + if (iodevice->isSequential()) { + if (origin == ZLIB_FILEFUNC_SEEK_END + && offset == 0) { + // sequential devices are always at end (needed in mdAppend) + return 0; + } else { + qWarning("qiodevice_seek_file_func() called for sequential device"); + return -1; + } + } + qint64 qiodevice_seek_result=0; + int ret; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR : + qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset; + break; + case ZLIB_FILEFUNC_SEEK_END : + qiodevice_seek_result = ((QIODevice*)stream)->size() - offset; + break; + case ZLIB_FILEFUNC_SEEK_SET : + qiodevice_seek_result = offset; + break; + default: + return -1; + } + ret = !iodevice->seek(qiodevice_seek_result); + return ret; +} + +int ZCALLBACK qiodevice_close_file_func ( + voidpf opaque, + voidpf stream) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + delete d; + QIODevice *device = reinterpret_cast(stream); +#ifdef QUAZIP_QSAVEFILE_BUG_WORKAROUND + // QSaveFile terribly breaks the is-a idiom: + // it IS a QIODevice, but it is NOT compatible with it: close() is private + QSaveFile *file = qobject_cast(device); + if (file != NULL) { + // We have to call the ugly commit() instead: + return file->commit() ? 0 : -1; + } +#endif + device->close(); + return 0; +} + +int ZCALLBACK qiodevice_fakeclose_file_func ( + voidpf opaque, + voidpf /*stream*/) +{ + QIODevice_descriptor *d = reinterpret_cast(opaque); + delete d; + return 0; +} + +int ZCALLBACK qiodevice_error_file_func ( + voidpf /*opaque UNUSED*/, + voidpf /*stream UNUSED*/) +{ + // can't check for error due to the QIODevice API limitation + return 0; +} + +void fill_qiodevice_filefunc ( + zlib_filefunc_def* pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen_file = qiodevice_open_file_func; + pzlib_filefunc_def->zread_file = qiodevice_read_file_func; + pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func; + pzlib_filefunc_def->ztell_file = qiodevice_tell_file_func; + pzlib_filefunc_def->zseek_file = qiodevice_seek_file_func; + pzlib_filefunc_def->zclose_file = qiodevice_close_file_func; + pzlib_filefunc_def->zerror_file = qiodevice_error_file_func; + pzlib_filefunc_def->opaque = new QIODevice_descriptor; +} + +void fill_qiodevice64_filefunc ( + zlib_filefunc64_def* pzlib_filefunc_def) +{ + // Open functions are the same for Qt. + pzlib_filefunc_def->zopen64_file = qiodevice_open_file_func; + pzlib_filefunc_def->zread_file = qiodevice_read_file_func; + pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func; + pzlib_filefunc_def->ztell64_file = qiodevice64_tell_file_func; + pzlib_filefunc_def->zseek64_file = qiodevice64_seek_file_func; + pzlib_filefunc_def->zclose_file = qiodevice_close_file_func; + pzlib_filefunc_def->zerror_file = qiodevice_error_file_func; + pzlib_filefunc_def->opaque = new QIODevice_descriptor; + pzlib_filefunc_def->zfakeclose_file = qiodevice_fakeclose_file_func; +} + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32) +{ + p_filefunc64_32->zfile_func64.zopen64_file = NULL; + p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file; + p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file; + p_filefunc64_32->zfile_func64.ztell64_file = NULL; + p_filefunc64_32->zfile_func64.zseek64_file = NULL; + p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque; + p_filefunc64_32->zfile_func64.zfakeclose_file = NULL; + p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file; + p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file; +} diff --git a/rbutil/rbutilqt/quazip/quazip.cpp b/rbutil/rbutilqt/quazip/quazip.cpp index 3f7314a433..e3623c76e3 100644 --- a/rbutil/rbutilqt/quazip/quazip.cpp +++ b/rbutil/rbutilqt/quazip/quazip.cpp @@ -1,94 +1,321 @@ /* --- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2007 Sergey A. Tachenov - -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. - -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. - -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - --- A kind of "standard" GPL license statement ends here -- - -See COPYING file for GPL. - -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. +Copyright (C) 2005-2014 Sergey A. Tachenov + +This file is part of QuaZIP. + +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. + +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. **/ #include +#include +#include #include "quazip.h" +/// All the internal stuff for the QuaZip class. +/** + \internal + + This class keeps all the private stuff for the QuaZip class so it can + be changed without breaking binary compatibility, according to the + Pimpl idiom. + */ +class QuaZipPrivate { + friend class QuaZip; + private: + /// The pointer to the corresponding QuaZip instance. + QuaZip *q; + /// The codec for file names. + QTextCodec *fileNameCodec; + /// The codec for comments. + QTextCodec *commentCodec; + /// The archive file name. + QString zipName; + /// The device to access the archive. + QIODevice *ioDevice; + /// The global comment. + QString comment; + /// The open mode. + QuaZip::Mode mode; + union { + /// The internal handle for UNZIP modes. + unzFile unzFile_f; + /// The internal handle for ZIP modes. + zipFile zipFile_f; + }; + /// Whether a current file is set. + bool hasCurrentFile_f; + /// The last error. + int zipError; + /// Whether \ref QuaZip::setDataDescriptorWritingEnabled() "the data descriptor writing mode" is enabled. + bool dataDescriptorWritingEnabled; + /// The zip64 mode. + bool zip64; + /// The auto-close flag. + bool autoClose; + inline QTextCodec *getDefaultFileNameCodec() + { + if (defaultFileNameCodec == NULL) { + return QTextCodec::codecForLocale(); + } else { + return defaultFileNameCodec; + } + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + ioDevice(NULL), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true) + { + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q, const QString &zipName): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + zipName(zipName), + ioDevice(NULL), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true) + { + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q, QIODevice *ioDevice): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + ioDevice(ioDevice), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true) + { + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// Returns either a list of file names or a list of QuaZipFileInfo. + template + bool getFileInfoList(QList *result) const; + + /// Stores map of filenames and file locations for unzipping + inline void clearDirectoryMap(); + inline void addCurrentFileToDirectoryMap(const QString &fileName); + bool goToFirstUnmappedFile(); + QHash directoryCaseSensitive; + QHash directoryCaseInsensitive; + unz64_file_pos lastMappedDirectoryEntry; + static QTextCodec *defaultFileNameCodec; +}; + +QTextCodec *QuaZipPrivate::defaultFileNameCodec = NULL; + +void QuaZipPrivate::clearDirectoryMap() +{ + directoryCaseInsensitive.clear(); + directoryCaseSensitive.clear(); + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; +} + +void QuaZipPrivate::addCurrentFileToDirectoryMap(const QString &fileName) +{ + if (!hasCurrentFile_f || fileName.isEmpty()) { + return; + } + // Adds current file to filename map as fileName + unz64_file_pos fileDirectoryPos; + unzGetFilePos64(unzFile_f, &fileDirectoryPos); + directoryCaseSensitive.insert(fileName, fileDirectoryPos); + // Only add lowercase to directory map if not already there + // ensures only map the first one seen + QString lower = fileName.toLower(); + if (!directoryCaseInsensitive.contains(lower)) + directoryCaseInsensitive.insert(lower, fileDirectoryPos); + // Mark last one + if (fileDirectoryPos.pos_in_zip_directory > lastMappedDirectoryEntry.pos_in_zip_directory) + lastMappedDirectoryEntry = fileDirectoryPos; +} + +bool QuaZipPrivate::goToFirstUnmappedFile() +{ + zipError = UNZ_OK; + if (mode != QuaZip::mdUnzip) { + qWarning("QuaZipPrivate::goToNextUnmappedFile(): ZIP is not open in mdUnzip mode"); + return false; + } + // If not mapped anything, go to beginning + if (lastMappedDirectoryEntry.pos_in_zip_directory == 0) { + unzGoToFirstFile(unzFile_f); + } else { + // Goto the last one mapped, plus one + unzGoToFilePos64(unzFile_f, &lastMappedDirectoryEntry); + unzGoToNextFile(unzFile_f); + } + hasCurrentFile_f=zipError==UNZ_OK; + if(zipError==UNZ_END_OF_LIST_OF_FILE) + zipError=UNZ_OK; + return hasCurrentFile_f; +} + QuaZip::QuaZip(): - fileNameCodec(QTextCodec::codecForLocale()), - commentCodec(QTextCodec::codecForLocale()), - mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK) + p(new QuaZipPrivate(this)) { } QuaZip::QuaZip(const QString& zipName): - fileNameCodec(QTextCodec::codecForLocale()), - commentCodec(QTextCodec::codecForLocale()), - zipName(zipName), - mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK) + p(new QuaZipPrivate(this, zipName)) +{ +} + +QuaZip::QuaZip(QIODevice *ioDevice): + p(new QuaZipPrivate(this, ioDevice)) { } QuaZip::~QuaZip() { - if(isOpen()) close(); + if(isOpen()) + close(); + delete p; } bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi) { - zipError=UNZ_OK; + p->zipError=UNZ_OK; if(isOpen()) { qWarning("QuaZip::open(): ZIP already opened"); return false; } + QIODevice *ioDevice = p->ioDevice; + if (ioDevice == NULL) { + if (p->zipName.isEmpty()) { + qWarning("QuaZip::open(): set either ZIP file name or IO device first"); + return false; + } else { + ioDevice = new QFile(p->zipName); + } + } + unsigned flags = 0; switch(mode) { case mdUnzip: - unzFile_f=unzOpen2(QFile::encodeName(zipName).constData(), ioApi); - if(unzFile_f!=NULL) { - this->mode=mode; + if (ioApi == NULL) { + if (p->autoClose) + flags |= UNZ_AUTO_CLOSE; + p->unzFile_f=unzOpenInternal(ioDevice, NULL, 1, flags); + } else { + // QuaZIP pre-zip64 compatibility mode + p->unzFile_f=unzOpen2(ioDevice, ioApi); + if (p->unzFile_f != NULL) { + if (p->autoClose) { + unzSetFlags(p->unzFile_f, UNZ_AUTO_CLOSE); + } else { + unzClearFlags(p->unzFile_f, UNZ_AUTO_CLOSE); + } + } + } + if(p->unzFile_f!=NULL) { + if (ioDevice->isSequential()) { + unzClose(p->unzFile_f); + if (!p->zipName.isEmpty()) + delete ioDevice; + qWarning("QuaZip::open(): " + "only mdCreate can be used with " + "sequential devices"); + return false; + } + p->mode=mode; + p->ioDevice = ioDevice; return true; } else { - zipError=UNZ_OPENERROR; + p->zipError=UNZ_OPENERROR; + if (!p->zipName.isEmpty()) + delete ioDevice; return false; } case mdCreate: case mdAppend: case mdAdd: - zipFile_f=zipOpen2(QFile::encodeName(zipName).constData(), - mode==mdCreate?APPEND_STATUS_CREATE: - mode==mdAppend?APPEND_STATUS_CREATEAFTER: - APPEND_STATUS_ADDINZIP, - NULL, - ioApi); - if(zipFile_f!=NULL) { - this->mode=mode; + if (ioApi == NULL) { + if (p->autoClose) + flags |= ZIP_AUTO_CLOSE; + if (p->dataDescriptorWritingEnabled) + flags |= ZIP_WRITE_DATA_DESCRIPTOR; + p->zipFile_f=zipOpen3(ioDevice, + mode==mdCreate?APPEND_STATUS_CREATE: + mode==mdAppend?APPEND_STATUS_CREATEAFTER: + APPEND_STATUS_ADDINZIP, + NULL, NULL, flags); + } else { + // QuaZIP pre-zip64 compatibility mode + p->zipFile_f=zipOpen2(ioDevice, + mode==mdCreate?APPEND_STATUS_CREATE: + mode==mdAppend?APPEND_STATUS_CREATEAFTER: + APPEND_STATUS_ADDINZIP, + NULL, + ioApi); + if (p->zipFile_f != NULL) { + zipSetFlags(p->zipFile_f, flags); + } + } + if(p->zipFile_f!=NULL) { + if (ioDevice->isSequential()) { + if (mode != mdCreate) { + zipClose(p->zipFile_f, NULL); + qWarning("QuaZip::open(): " + "only mdCreate can be used with " + "sequential devices"); + if (!p->zipName.isEmpty()) + delete ioDevice; + return false; + } + zipSetFlags(p->zipFile_f, ZIP_SEQUENTIAL); + } + p->mode=mode; + p->ioDevice = ioDevice; return true; } else { - zipError=UNZ_OPENERROR; + p->zipError=UNZ_OPENERROR; + if (!p->zipName.isEmpty()) + delete ioDevice; return false; } default: qWarning("QuaZip::open(): unknown mode: %d", (int)mode); + if (!p->zipName.isEmpty()) + delete ioDevice; return false; break; } @@ -96,24 +323,33 @@ bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi) void QuaZip::close() { - zipError=UNZ_OK; - switch(mode) { + p->zipError=UNZ_OK; + switch(p->mode) { case mdNotOpen: qWarning("QuaZip::close(): ZIP is not open"); return; case mdUnzip: - zipError=unzClose(unzFile_f); + p->zipError=unzClose(p->unzFile_f); break; case mdCreate: case mdAppend: case mdAdd: - zipError=zipClose(zipFile_f, commentCodec->fromUnicode(comment).constData()); + p->zipError=zipClose(p->zipFile_f, + p->comment.isNull() ? NULL + : p->commentCodec->fromUnicode(p->comment).constData()); break; default: - qWarning("QuaZip::close(): unknown mode: %d", (int)mode); + qWarning("QuaZip::close(): unknown mode: %d", (int)p->mode); return; } - if(zipError==UNZ_OK) mode=mdNotOpen; + // opened by name, need to delete the internal IO device + if (!p->zipName.isEmpty()) { + delete p->ioDevice; + p->ioDevice = NULL; + } + p->clearDirectoryMap(); + if(p->zipError==UNZ_OK) + p->mode=mdNotOpen; } void QuaZip::setZipName(const QString& zipName) @@ -122,129 +358,171 @@ void QuaZip::setZipName(const QString& zipName) qWarning("QuaZip::setZipName(): ZIP is already open!"); return; } - this->zipName=zipName; + p->zipName=zipName; + p->ioDevice = NULL; +} + +void QuaZip::setIoDevice(QIODevice *ioDevice) +{ + if(isOpen()) { + qWarning("QuaZip::setIoDevice(): ZIP is already open!"); + return; + } + p->ioDevice = ioDevice; + p->zipName = QString(); } int QuaZip::getEntriesCount()const { QuaZip *fakeThis=(QuaZip*)this; // non-const - fakeThis->zipError=UNZ_OK; - if(mode!=mdUnzip) { + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode"); return -1; } - unz_global_info globalInfo; - if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK) - return zipError; + unz_global_info64 globalInfo; + if((fakeThis->p->zipError=unzGetGlobalInfo64(p->unzFile_f, &globalInfo))!=UNZ_OK) + return p->zipError; return (int)globalInfo.number_entry; } QString QuaZip::getComment()const { QuaZip *fakeThis=(QuaZip*)this; // non-const - fakeThis->zipError=UNZ_OK; - if(mode!=mdUnzip) { + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode"); return QString(); } - unz_global_info globalInfo; + unz_global_info64 globalInfo; QByteArray comment; - if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK) + if((fakeThis->p->zipError=unzGetGlobalInfo64(p->unzFile_f, &globalInfo))!=UNZ_OK) return QString(); comment.resize(globalInfo.size_comment); - if((fakeThis->zipError=unzGetGlobalComment(unzFile_f, comment.data(), comment.size()))!=UNZ_OK) + if((fakeThis->p->zipError=unzGetGlobalComment(p->unzFile_f, comment.data(), comment.size())) < 0) return QString(); - return commentCodec->toUnicode(comment); + fakeThis->p->zipError = UNZ_OK; + return p->commentCodec->toUnicode(comment); } bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs) { - zipError=UNZ_OK; - if(mode!=mdUnzip) { + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode"); return false; } - if(fileName.isNull()) { - hasCurrentFile_f=false; + if(fileName.isEmpty()) { + p->hasCurrentFile_f=false; return true; } // Unicode-aware reimplementation of the unzLocateFile function - if(unzFile_f==NULL) { - zipError=UNZ_PARAMERROR; + if(p->unzFile_f==NULL) { + p->zipError=UNZ_PARAMERROR; return false; } if(fileName.length()>MAX_FILE_NAME_LENGTH) { - zipError=UNZ_PARAMERROR; + p->zipError=UNZ_PARAMERROR; return false; } - bool sens; - if(cs==csDefault) { -#ifdef Q_WS_WIN - sens=false; -#else - sens=true; -#endif - } else sens=cs==csSensitive; + // Find the file by name + bool sens = convertCaseSensitivity(cs) == Qt::CaseSensitive; QString lower, current; if(!sens) lower=fileName.toLower(); - hasCurrentFile_f=false; - for(bool more=goToFirstFile(); more; more=goToNextFile()) { + p->hasCurrentFile_f=false; + + // Check the appropriate Map + unz64_file_pos fileDirPos; + fileDirPos.pos_in_zip_directory = 0; + if (sens) { + if (p->directoryCaseSensitive.contains(fileName)) + fileDirPos = p->directoryCaseSensitive.value(fileName); + } else { + if (p->directoryCaseInsensitive.contains(lower)) + fileDirPos = p->directoryCaseInsensitive.value(lower); + } + + if (fileDirPos.pos_in_zip_directory != 0) { + p->zipError = unzGoToFilePos64(p->unzFile_f, &fileDirPos); + p->hasCurrentFile_f = p->zipError == UNZ_OK; + } + + if (p->hasCurrentFile_f) + return p->hasCurrentFile_f; + + // Not mapped yet, start from where we have got to so far + for(bool more=p->goToFirstUnmappedFile(); more; more=goToNextFile()) { current=getCurrentFileName(); - if(current.isNull()) return false; + if(current.isEmpty()) return false; if(sens) { if(current==fileName) break; } else { if(current.toLower()==lower) break; } } - return hasCurrentFile_f; + return p->hasCurrentFile_f; } bool QuaZip::goToFirstFile() { - zipError=UNZ_OK; - if(mode!=mdUnzip) { + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); return false; } - zipError=unzGoToFirstFile(unzFile_f); - hasCurrentFile_f=zipError==UNZ_OK; - return hasCurrentFile_f; + p->zipError=unzGoToFirstFile(p->unzFile_f); + p->hasCurrentFile_f=p->zipError==UNZ_OK; + return p->hasCurrentFile_f; } bool QuaZip::goToNextFile() { - zipError=UNZ_OK; - if(mode!=mdUnzip) { + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); return false; } - zipError=unzGoToNextFile(unzFile_f); - hasCurrentFile_f=zipError==UNZ_OK; - if(zipError==UNZ_END_OF_LIST_OF_FILE) zipError=UNZ_OK; - return hasCurrentFile_f; + p->zipError=unzGoToNextFile(p->unzFile_f); + p->hasCurrentFile_f=p->zipError==UNZ_OK; + if(p->zipError==UNZ_END_OF_LIST_OF_FILE) + p->zipError=UNZ_OK; + return p->hasCurrentFile_f; } bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const +{ + QuaZipFileInfo64 info64; + if (info == NULL) { // Very unlikely because of the overloads + return false; + } + if (getCurrentFileInfo(&info64)) { + info64.toQuaZipFileInfo(*info); + return true; + } else { + return false; + } +} + +bool QuaZip::getCurrentFileInfo(QuaZipFileInfo64 *info)const { QuaZip *fakeThis=(QuaZip*)this; // non-const - fakeThis->zipError=UNZ_OK; - if(mode!=mdUnzip) { + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::getCurrentFileInfo(): ZIP is not open in mdUnzip mode"); return false; } - unz_file_info info_z; + unz_file_info64 info_z; QByteArray fileName; QByteArray extra; QByteArray comment; if(info==NULL) return false; if(!isOpen()||!hasCurrentFile()) return false; - if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK) + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK) return false; fileName.resize(info_z.size_filename); extra.resize(info_z.size_file_extra); comment.resize(info_z.size_file_comment); - if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, NULL, + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, NULL, fileName.data(), fileName.size(), extra.data(), extra.size(), comment.data(), comment.size()))!=UNZ_OK) @@ -259,27 +537,252 @@ bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const info->diskNumberStart=info_z.disk_num_start; info->internalAttr=info_z.internal_fa; info->externalAttr=info_z.external_fa; - info->name=fileNameCodec->toUnicode(fileName); - info->comment=commentCodec->toUnicode(comment); + info->name=p->fileNameCodec->toUnicode(fileName); + info->comment=p->commentCodec->toUnicode(comment); info->extra=extra; info->dateTime=QDateTime( QDate(info_z.tmu_date.tm_year, info_z.tmu_date.tm_mon+1, info_z.tmu_date.tm_mday), QTime(info_z.tmu_date.tm_hour, info_z.tmu_date.tm_min, info_z.tmu_date.tm_sec)); + // Add to directory map + p->addCurrentFileToDirectoryMap(info->name); return true; } QString QuaZip::getCurrentFileName()const { QuaZip *fakeThis=(QuaZip*)this; // non-const - fakeThis->zipError=UNZ_OK; - if(mode!=mdUnzip) { + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { qWarning("QuaZip::getCurrentFileName(): ZIP is not open in mdUnzip mode"); return QString(); } if(!isOpen()||!hasCurrentFile()) return QString(); QByteArray fileName(MAX_FILE_NAME_LENGTH, 0); - if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, NULL, fileName.data(), fileName.size(), + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, NULL, fileName.data(), fileName.size(), NULL, 0, NULL, 0))!=UNZ_OK) return QString(); - return fileNameCodec->toUnicode(fileName.constData()); + QString result = p->fileNameCodec->toUnicode(fileName.constData()); + if (result.isEmpty()) + return result; + // Add to directory map + p->addCurrentFileToDirectoryMap(result); + return result; +} + +void QuaZip::setFileNameCodec(QTextCodec *fileNameCodec) +{ + p->fileNameCodec=fileNameCodec; +} + +void QuaZip::setFileNameCodec(const char *fileNameCodecName) +{ + p->fileNameCodec=QTextCodec::codecForName(fileNameCodecName); +} + +QTextCodec *QuaZip::getFileNameCodec()const +{ + return p->fileNameCodec; +} + +void QuaZip::setCommentCodec(QTextCodec *commentCodec) +{ + p->commentCodec=commentCodec; +} + +void QuaZip::setCommentCodec(const char *commentCodecName) +{ + p->commentCodec=QTextCodec::codecForName(commentCodecName); +} + +QTextCodec *QuaZip::getCommentCodec()const +{ + return p->commentCodec; +} + +QString QuaZip::getZipName() const +{ + return p->zipName; +} + +QIODevice *QuaZip::getIoDevice() const +{ + if (!p->zipName.isEmpty()) // opened by name, using an internal QIODevice + return NULL; + return p->ioDevice; +} + +QuaZip::Mode QuaZip::getMode()const +{ + return p->mode; +} + +bool QuaZip::isOpen()const +{ + return p->mode!=mdNotOpen; +} + +int QuaZip::getZipError() const +{ + return p->zipError; +} + +void QuaZip::setComment(const QString& comment) +{ + p->comment=comment; +} + +bool QuaZip::hasCurrentFile()const +{ + return p->hasCurrentFile_f; +} + +unzFile QuaZip::getUnzFile() +{ + return p->unzFile_f; +} + +zipFile QuaZip::getZipFile() +{ + return p->zipFile_f; +} + +void QuaZip::setDataDescriptorWritingEnabled(bool enabled) +{ + p->dataDescriptorWritingEnabled = enabled; +} + +bool QuaZip::isDataDescriptorWritingEnabled() const +{ + return p->dataDescriptorWritingEnabled; +} + +template +TFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok); + +template<> +QuaZipFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QuaZipFileInfo info; + *ok = zip->getCurrentFileInfo(&info); + return info; +} + +template<> +QuaZipFileInfo64 QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QuaZipFileInfo64 info; + *ok = zip->getCurrentFileInfo(&info); + return info; +} + +template<> +QString QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QString name = zip->getCurrentFileName(); + *ok = !name.isEmpty(); + return name; +} + +template +bool QuaZipPrivate::getFileInfoList(QList *result) const +{ + QuaZipPrivate *fakeThis=const_cast(this); + fakeThis->zipError=UNZ_OK; + if (mode!=QuaZip::mdUnzip) { + qWarning("QuaZip::getFileNameList/getFileInfoList(): " + "ZIP is not open in mdUnzip mode"); + return false; + } + QString currentFile; + if (q->hasCurrentFile()) { + currentFile = q->getCurrentFileName(); + } + if (q->goToFirstFile()) { + do { + bool ok; + result->append(QuaZip_getFileInfo(q, &ok)); + if (!ok) + return false; + } while (q->goToNextFile()); + } + if (zipError != UNZ_OK) + return false; + if (currentFile.isEmpty()) { + if (!q->goToFirstFile()) + return false; + } else { + if (!q->setCurrentFile(currentFile)) + return false; + } + return true; +} + +QStringList QuaZip::getFileNameList() const +{ + QStringList list; + if (p->getFileInfoList(&list)) + return list; + else + return QStringList(); +} + +QList QuaZip::getFileInfoList() const +{ + QList list; + if (p->getFileInfoList(&list)) + return list; + else + return QList(); +} + +QList QuaZip::getFileInfoList64() const +{ + QList list; + if (p->getFileInfoList(&list)) + return list; + else + return QList(); +} + +Qt::CaseSensitivity QuaZip::convertCaseSensitivity(QuaZip::CaseSensitivity cs) +{ + if (cs == csDefault) { +#ifdef Q_WS_WIN + return Qt::CaseInsensitive; +#else + return Qt::CaseSensitive; +#endif + } else { + return cs == csSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive; + } +} + +void QuaZip::setDefaultFileNameCodec(QTextCodec *codec) +{ + QuaZipPrivate::defaultFileNameCodec = codec; +} + +void QuaZip::setDefaultFileNameCodec(const char *codecName) +{ + setDefaultFileNameCodec(QTextCodec::codecForName(codecName)); +} + +void QuaZip::setZip64Enabled(bool zip64) +{ + p->zip64 = zip64; +} + +bool QuaZip::isZip64Enabled() const +{ + return p->zip64; +} + +bool QuaZip::isAutoClose() const +{ + return p->autoClose; +} + +void QuaZip::setAutoClose(bool autoClose) const +{ + p->autoClose = autoClose; } diff --git a/rbutil/rbutilqt/quazip/quazip.h b/rbutil/rbutilqt/quazip/quazip.h index ced1ea0f1a..ae2c8f494f 100644 --- a/rbutil/rbutilqt/quazip/quazip.h +++ b/rbutil/rbutilqt/quazip/quazip.h @@ -2,43 +2,37 @@ #define QUA_ZIP_H /* --- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2007 Sergey A. Tachenov +Copyright (C) 2005-2014 Sergey A. Tachenov -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. +This file is part of QuaZIP. -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. --- A kind of "standard" GPL license statement ends here -- +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . -See COPYING file for GPL. +See COPYING file for the full LGPL text. -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. **/ #include +#include #include #include "zip.h" #include "unzip.h" +#include "quazip_global.h" #include "quazipfileinfo.h" // just in case it will be defined in the later versions of the ZIP/UNZIP @@ -47,6 +41,8 @@ QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. #define UNZ_OPENERROR -1000 #endif +class QuaZipPrivate; + /// ZIP archive. /** \class QuaZip quazip.h * This class implements basic interface to the ZIP archive. It can be @@ -85,7 +81,8 @@ QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. * detection using locale information. Does anyone know a good way to do * it? **/ -class QuaZip { +class QUAZIP_EXPORT QuaZip { + friend class QuaZipPrivate; public: /// Useful constants. enum Constants { @@ -119,17 +116,17 @@ class QuaZip { csSensitive=1, ///< Case sensitive. csInsensitive=2 ///< Case insensitive. }; + /// Returns the actual case sensitivity for the specified QuaZIP one. + /** + \param cs The value to convert. + \returns If CaseSensitivity::csDefault, then returns the default + file name case sensitivity for the platform. Otherwise, just + returns the appropriate value from the Qt::CaseSensitivity enum. + */ + static Qt::CaseSensitivity convertCaseSensitivity( + CaseSensitivity cs); private: - QTextCodec *fileNameCodec, *commentCodec; - QString zipName; - QString comment; - Mode mode; - union { - unzFile unzFile_f; - zipFile zipFile_f; - }; - bool hasCurrentFile_f; - int zipError; + QuaZipPrivate *p; // not (and will not be) implemented QuaZip(const QuaZip& that); // not (and will not be) implemented @@ -140,39 +137,83 @@ class QuaZip { QuaZip(); /// Constructs QuaZip object associated with ZIP file \a zipName. QuaZip(const QString& zipName); + /// Constructs QuaZip object associated with ZIP file represented by \a ioDevice. + /** The IO device must be seekable, otherwise an error will occur when opening. */ + QuaZip(QIODevice *ioDevice); /// Destroys QuaZip object. /** Calls close() if necessary. */ ~QuaZip(); /// Opens ZIP file. - /** Argument \a ioApi specifies IO function set for ZIP/UNZIP - * package to use. See unzip.h, zip.h and ioapi.h for details. By - * passing NULL (the default) you just tell package to use the - * default API which works just fine on UNIX platforms. I have tried - * it on win32-g++ platform too and it seems it works fine there - * too, so I see no reason to use win32 IO API included in original - * ZIP/UNZIP package. - * - * ZIP archive file name will be converted to 8-bit encoding using - * Qt's QFile::encodeName() function before passing it to the - * ZIP/UNZIP package API. - * - * Returns \c true if successful, \c false otherwise. - * + /** * Argument \a mode specifies open mode of the ZIP archive. See Mode * for details. Note that there is zipOpen2() function in the * ZIP/UNZIP API which accepts \a globalcomment argument, but it * does not use it anywhere, so this open() function does not have this * argument. See setComment() if you need to set global comment. * + * If the ZIP file is accessed via explicitly set QIODevice, then + * this device is opened in the necessary mode. If the device was + * already opened by some other means, then QuaZIP checks if the + * open mode is compatible to the mode needed for the requested operation. + * If necessary, seeking is performed to position the device properly. + * + * \return \c true if successful, \c false otherwise. + * * \note ZIP/UNZIP API open calls do not return error code - they * just return \c NULL indicating an error. But to make things * easier, quazip.h header defines additional error code \c * UNZ_ERROROPEN and getZipError() will return it if the open call * of the ZIP/UNZIP API returns \c NULL. + * + * Argument \a ioApi specifies IO function set for ZIP/UNZIP + * package to use. See unzip.h, zip.h and ioapi.h for details. Note + * that IO API for QuaZip is different from the original package. + * The file path argument was changed to be of type \c voidpf, and + * QuaZip passes a QIODevice pointer there. This QIODevice is either + * set explicitly via setIoDevice() or the QuaZip(QIODevice*) + * constructor, or it is created internally when opening the archive + * by its file name. The default API (qioapi.cpp) just delegates + * everything to the QIODevice API. Not only this allows to use a + * QIODevice instead of file name, but also has a nice side effect + * of raising the file size limit from 2G to 4G (in non-zip64 archives). + * + * \note If the zip64 support is needed, the ioApi argument \em must be NULL + * because due to the backwards compatibility issues it can be used to + * provide a 32-bit API only. + * + * \note If the \ref QuaZip::setAutoClose() "no-auto-close" feature is used, + * then the \a ioApi argument \em should be NULL because the old API + * doesn't support the 'fake close' operation, causing slight memory leaks + * and other possible troubles (like closing the output device in case + * when an error occurs during opening). + * + * In short: just forget about the \a ioApi argument and you'll be + * fine. **/ bool open(Mode mode, zlib_filefunc_def *ioApi =NULL); /// Closes ZIP file. - /** Call getZipError() to determine if the close was successful. */ + /** Call getZipError() to determine if the close was successful. + * + * If the file was opened by name, then the underlying QIODevice is closed + * and deleted. + * + * If the underlying QIODevice was set explicitly using setIoDevice() or + * the appropriate constructor, then it is closed if the auto-close flag + * is set (which it is by default). Call setAutoClose() to clear the + * auto-close flag if this behavior is undesirable. + * + * Since Qt 5.1, the QSaveFile was introduced. It breaks the QIODevice API + * by making close() private and crashing the application if it is called + * from the base class where it is public. It is an excellent example + * of poor design that illustrates why you should never ever break + * an is-a relationship between the base class and a subclass. QuaZIP + * works around this bug by checking if the QIODevice is an instance + * of QSaveFile, using qobject_cast<>, and if it is, calls + * QSaveFile::commit() instead of close(). It is a really ugly hack, + * but at least it makes your programs work instead of crashing. Note that + * if the auto-close flag is cleared, then this is a non-issue, and + * commit() isn't called. + */ void close(); /// Sets the codec used to encode/decode file names inside archive. /** This is necessary to access files in the ZIP archive created @@ -180,44 +221,56 @@ class QuaZip { * example, file names with cyrillic letters will be in \c IBM866 * encoding. **/ - void setFileNameCodec(QTextCodec *fileNameCodec) - {this->fileNameCodec=fileNameCodec;} + void setFileNameCodec(QTextCodec *fileNameCodec); /// Sets the codec used to encode/decode file names inside archive. /** \overload * Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName)); **/ - void setFileNameCodec(const char *fileNameCodecName) - {fileNameCodec=QTextCodec::codecForName(fileNameCodecName);} + void setFileNameCodec(const char *fileNameCodecName); /// Returns the codec used to encode/decode comments inside archive. - QTextCodec* getFileNameCodec()const {return fileNameCodec;} + QTextCodec* getFileNameCodec() const; /// Sets the codec used to encode/decode comments inside archive. /** This codec defaults to locale codec, which is probably ok. **/ - void setCommentCodec(QTextCodec *commentCodec) - {this->commentCodec=commentCodec;} + void setCommentCodec(QTextCodec *commentCodec); /// Sets the codec used to encode/decode comments inside archive. /** \overload * Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName)); **/ - void setCommentCodec(const char *commentCodecName) - {commentCodec=QTextCodec::codecForName(commentCodecName);} + void setCommentCodec(const char *commentCodecName); /// Returns the codec used to encode/decode comments inside archive. - QTextCodec* getCommentCodec()const {return commentCodec;} + QTextCodec* getCommentCodec() const; /// Returns the name of the ZIP file. - /** Returns null string if no ZIP file name has been set. - * \sa setZipName() + /** Returns null string if no ZIP file name has been set, for + * example when the QuaZip instance is set up to use a QIODevice + * instead. + * \sa setZipName(), setIoDevice(), getIoDevice() **/ - QString getZipName()const {return zipName;} + QString getZipName() const; /// Sets the name of the ZIP file. /** Does nothing if the ZIP file is open. * * Does not reset error code returned by getZipError(). + * \sa setIoDevice(), getIoDevice(), getZipName() **/ void setZipName(const QString& zipName); + /// Returns the device representing this ZIP file. + /** Returns null string if no device has been set explicitly, for + * example when opening a ZIP file by name. + * \sa setIoDevice(), getZipName(), setZipName() + **/ + QIODevice *getIoDevice() const; + /// Sets the device representing the ZIP file. + /** Does nothing if the ZIP file is open. + * + * Does not reset error code returned by getZipError(). + * \sa getIoDevice(), getZipName(), setZipName() + **/ + void setIoDevice(QIODevice *ioDevice); /// Returns the mode in which ZIP file was opened. - Mode getMode()const {return mode;} + Mode getMode() const; /// Returns \c true if ZIP file is open, \c false otherwise. - bool isOpen()const {return mode!=mdNotOpen;} + bool isOpen() const; /// Returns the error code of the last operation. /** Returns \c UNZ_OK if the last operation was successful. * @@ -227,20 +280,24 @@ class QuaZip { * error code too. See documentation for the specific functions for * details on error detection. **/ - int getZipError()const {return zipError;} + int getZipError() const; /// Returns number of the entries in the ZIP central directory. /** Returns negative error code in the case of error. The same error * code will be returned by subsequent getZipError() call. **/ - int getEntriesCount()const; + int getEntriesCount() const; /// Returns global comment in the ZIP file. - QString getComment()const; - /// Sets global comment in the ZIP file. - /** Comment will be written to the archive on close operation. + QString getComment() const; + /// Sets the global comment in the ZIP file. + /** The comment will be written to the archive on close operation. + * QuaZip makes a distinction between a null QByteArray() comment + * and an empty "" comment in the QuaZip::mdAdd mode. + * A null comment is the default and it means "don't change + * the comment". An empty comment removes the original comment. * * \sa open() **/ - void setComment(const QString& comment) {this->comment=comment;} + void setComment(const QString& comment); /// Sets the current file to the first file in the archive. /** Returns \c true on success, \c false otherwise. Call * getZipError() to get the error code. @@ -292,7 +349,7 @@ class QuaZip { **/ bool setCurrentFile(const QString& fileName, CaseSensitivity cs =csDefault); /// Returns \c true if the current file has been set. - bool hasCurrentFile()const {return hasCurrentFile_f;} + bool hasCurrentFile() const; /// Retrieves information about the current file. /** Fills the structure pointed by \a info. Returns \c true on * success, \c false otherwise. In the latter case structure pointed @@ -303,13 +360,29 @@ class QuaZip { * * Does nothing and returns \c false in any of the following cases. * - ZIP is not open; - * - ZIP does not have current file; - * - \a info is \c NULL; + * - ZIP does not have current file. * - * In all these cases getZipError() returns \c UNZ_OK since there + * In both cases getZipError() returns \c UNZ_OK since there * is no ZIP/UNZIP API call. + * + * This overload doesn't support zip64, but will work OK on zip64 archives + * except that if one of the sizes (compressed or uncompressed) is greater + * than 0xFFFFFFFFu, it will be set to exactly 0xFFFFFFFFu. + * + * \sa getCurrentFileInfo(QuaZipFileInfo64* info)const + * \sa QuaZipFileInfo64::toQuaZipFileInfo(QuaZipFileInfo&)const **/ bool getCurrentFileInfo(QuaZipFileInfo* info)const; + /// Retrieves information about the current file. + /** \overload + * + * This function supports zip64. If the archive doesn't use zip64, it is + * completely equivalent to getCurrentFileInfo(QuaZipFileInfo* info) + * except for the argument type. + * + * \sa + **/ + bool getCurrentFileInfo(QuaZipFileInfo64* info)const; /// Returns the current file name. /** Equivalent to calling getCurrentFileInfo() and then getting \c * name field of the QuaZipFileInfo structure, but faster and more @@ -334,13 +407,165 @@ class QuaZip { * file in the ZIP archive - then change it back or you may * experience some strange behavior or even crashes. **/ - unzFile getUnzFile() {return unzFile_f;} + unzFile getUnzFile(); /// Returns \c zipFile handle. /** You can use this handle to directly call ZIP part of the * ZIP/UNZIP package functions (see zip.h). Warnings about the * getUnzFile() function also apply to this function. **/ - zipFile getZipFile() {return zipFile_f;} + zipFile getZipFile(); + /// Changes the data descriptor writing mode. + /** + According to the ZIP format specification, a file inside archive + may have a data descriptor immediately following the file + data. This is reflected by a special flag in the local file header + and in the central directory. By default, QuaZIP sets this flag + and writes the data descriptor unless both method and level were + set to 0, in which case it operates in 1.0-compatible mode and + never writes data descriptors. + + By setting this flag to false, it is possible to disable data + descriptor writing, thus increasing compatibility with archive + readers that don't understand this feature of the ZIP file format. + + Setting this flag affects all the QuaZipFile instances that are + opened after this flag is set. + + The data descriptor writing mode is enabled by default. + + Note that if the ZIP archive is written into a QIODevice for which + QIODevice::isSequential() returns \c true, then the data descriptor + is mandatory and will be written even if this flag is set to false. + + \param enabled If \c true, enable local descriptor writing, + disable it otherwise. + + \sa QuaZipFile::isDataDescriptorWritingEnabled() + */ + void setDataDescriptorWritingEnabled(bool enabled); + /// Returns the data descriptor default writing mode. + /** + \sa setDataDescriptorWritingEnabled() + */ + bool isDataDescriptorWritingEnabled() const; + /// Returns a list of files inside the archive. + /** + \return A list of file names or an empty list if there + was an error or if the archive is empty (call getZipError() to + figure out which). + \sa getFileInfoList() + */ + QStringList getFileNameList() const; + /// Returns information list about all files inside the archive. + /** + \return A list of QuaZipFileInfo objects or an empty list if there + was an error or if the archive is empty (call getZipError() to + figure out which). + + This function doesn't support zip64, but will still work with zip64 + archives, converting results using QuaZipFileInfo64::toQuaZipFileInfo(). + If all file sizes are below 4 GB, it will work just fine. + + \sa getFileNameList() + \sa getFileInfoList64() + */ + QList getFileInfoList() const; + /// Returns information list about all files inside the archive. + /** + \overload + + This function supports zip64. + + \sa getFileNameList() + \sa getFileInfoList() + */ + QList getFileInfoList64() const; + /// Enables the zip64 mode. + /** + * @param zip64 If \c true, the zip64 mode is enabled, disabled otherwise. + * + * Once this is enabled, all new files (until the mode is disabled again) + * will be created in the zip64 mode, thus enabling the ability to write + * files larger than 4 GB. By default, the zip64 mode is off due to + * compatibility reasons. + * + * Note that this does not affect the ability to read zip64 archives in any + * way. + * + * \sa isZip64Enabled() + */ + void setZip64Enabled(bool zip64); + /// Returns whether the zip64 mode is enabled. + /** + * @return \c true if and only if the zip64 mode is enabled. + * + * \sa setZip64Enabled() + */ + bool isZip64Enabled() const; + /// Returns the auto-close flag. + /** + @sa setAutoClose() + */ + bool isAutoClose() const; + /// Sets or unsets the auto-close flag. + /** + By default, QuaZIP opens the underlying QIODevice when open() is called, + and closes it when close() is called. In some cases, when the device + is set explicitly using setIoDevice(), it may be desirable to + leave the device open. If the auto-close flag is unset using this method, + then the device isn't closed automatically if it was set explicitly. + + If it is needed to clear this flag, it is recommended to do so before + opening the archive because otherwise QuaZIP may close the device + during the open() call if an error is encountered after the device + is opened. + + If the device was not set explicitly, but rather the setZipName() or + the appropriate constructor was used to set the ZIP file name instead, + then the auto-close flag has no effect, and the internal device + is closed nevertheless because there is no other way to close it. + + @sa isAutoClose() + @sa setIoDevice() + */ + void setAutoClose(bool autoClose) const; + /// Sets the default file name codec to use. + /** + * The default codec is used by the constructors, so calling this function + * won't affect the QuaZip instances already created at that moment. + * + * The codec specified here can be overriden by calling setFileNameCodec(). + * If neither function is called, QTextCodec::codecForLocale() will be used + * to decode or encode file names. Use this function with caution if + * the application uses other libraries that depend on QuaZIP. Those + * libraries can either call this function by themselves, thus overriding + * your setting or can rely on the default encoding, thus failing + * mysteriously if you change it. For these reasons, it isn't recommended + * to use this function if you are developing a library, not an application. + * Instead, ask your library users to call it in case they need specific + * encoding. + * + * In most cases, using setFileNameCodec() instead is the right choice. + * However, if you depend on third-party code that uses QuaZIP, then the + * reasons stated above can actually become a reason to use this function + * in case the third-party code in question fails because it doesn't + * understand the encoding you need and doesn't provide a way to specify it. + * This applies to the JlCompress class as well, as it was contributed and + * doesn't support explicit encoding parameters. + * + * In short: use setFileNameCodec() when you can, resort to + * setDefaultFileNameCodec() when you don't have access to the QuaZip + * instance. + * + * @param codec The codec to use by default. If NULL, resets to default. + */ + static void setDefaultFileNameCodec(QTextCodec *codec); + /** + * @overload + * Equivalent to calling + * setDefltFileNameCodec(QTextCodec::codecForName(codecName)). + */ + static void setDefaultFileNameCodec(const char *codecName); }; #endif diff --git a/rbutil/rbutilqt/quazip/quazip_global.h b/rbutil/rbutilqt/quazip/quazip_global.h new file mode 100644 index 0000000000..7e3798afc1 --- /dev/null +++ b/rbutil/rbutilqt/quazip/quazip_global.h @@ -0,0 +1,59 @@ +#ifndef QUAZIP_GLOBAL_H +#define QUAZIP_GLOBAL_H + +/* +Copyright (C) 2005-2014 Sergey A. Tachenov + +This file is part of QuaZIP. + +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. + +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant and contributors, +see quazip/(un)zip.h files for details. Basically it's the zlib license. +*/ + +#include + +/** + This is automatically defined when building a static library, but when + including QuaZip sources directly into a project, QUAZIP_STATIC should + be defined explicitly to avoid possible troubles with unnecessary + importing/exporting. + */ +#ifdef QUAZIP_STATIC +#define QUAZIP_EXPORT +#else +/** + * When building a DLL with MSVC, QUAZIP_BUILD must be defined. + * qglobal.h takes care of defining Q_DECL_* correctly for msvc/gcc. + */ +#if defined(QUAZIP_BUILD) + #define QUAZIP_EXPORT Q_DECL_EXPORT +#else + #define QUAZIP_EXPORT Q_DECL_IMPORT +#endif +#endif // QUAZIP_STATIC + +#ifdef __GNUC__ +#define UNUSED __attribute__((__unused__)) +#else +#define UNUSED +#endif + +#define QUAZIP_EXTRA_NTFS_MAGIC 0x000Au +#define QUAZIP_EXTRA_NTFS_TIME_MAGIC 0x0001u + +#endif // QUAZIP_GLOBAL_H diff --git a/rbutil/rbutilqt/quazip/quazipfile.cpp b/rbutil/rbutilqt/quazip/quazipfile.cpp index 0399d1dbd0..8d56417698 100644 --- a/rbutil/rbutilqt/quazip/quazipfile.cpp +++ b/rbutil/rbutilqt/quazip/quazipfile.cpp @@ -1,91 +1,165 @@ /* --- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2007 Sergey A. Tachenov - -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. - -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. - -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - --- A kind of "standard" GPL license statement ends here -- - -See COPYING file for GPL. - -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. +Copyright (C) 2005-2014 Sergey A. Tachenov + +This file is part of QuaZIP. + +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. + +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. **/ #include "quazipfile.h" using namespace std; +/// The implementation class for QuaZip. +/** +\internal + +This class contains all the private stuff for the QuaZipFile class, thus +allowing to preserve binary compatibility between releases, the +technique known as the Pimpl (private implementation) idiom. +*/ +class QuaZipFilePrivate { + friend class QuaZipFile; + private: + /// The pointer to the associated QuaZipFile instance. + QuaZipFile *q; + /// The QuaZip object to work with. + QuaZip *zip; + /// The file name. + QString fileName; + /// Case sensitivity mode. + QuaZip::CaseSensitivity caseSensitivity; + /// Whether this file is opened in the raw mode. + bool raw; + /// Write position to keep track of. + /** + QIODevice::pos() is broken for non-seekable devices, so we need + our own position. + */ + qint64 writePos; + /// Uncompressed size to write along with a raw file. + quint64 uncompressedSize; + /// CRC to write along with a raw file. + quint32 crc; + /// Whether \ref zip points to an internal QuaZip instance. + /** + This is true if the archive was opened by name, rather than by + supplying an existing QuaZip instance. + */ + bool internal; + /// The last error. + int zipError; + /// Resets \ref zipError. + inline void resetZipError() const {setZipError(UNZ_OK);} + /// Sets the zip error. + /** + This function is marked as const although it changes one field. + This allows to call it from const functions that don't change + anything by themselves. + */ + void setZipError(int zipError) const; + /// The constructor for the corresponding QuaZipFile constructor. + inline QuaZipFilePrivate(QuaZipFile *q): + q(q), zip(NULL), internal(true), zipError(UNZ_OK) {} + /// The constructor for the corresponding QuaZipFile constructor. + inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName): + q(q), internal(true), zipError(UNZ_OK) + { + zip=new QuaZip(zipName); + } + /// The constructor for the corresponding QuaZipFile constructor. + inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName, const QString &fileName, + QuaZip::CaseSensitivity cs): + q(q), internal(true), zipError(UNZ_OK) + { + zip=new QuaZip(zipName); + this->fileName=fileName; + if (this->fileName.startsWith('/')) + this->fileName = this->fileName.mid(1); + this->caseSensitivity=cs; + } + /// The constructor for the QuaZipFile constructor accepting a file name. + inline QuaZipFilePrivate(QuaZipFile *q, QuaZip *zip): + q(q), zip(zip), internal(false), zipError(UNZ_OK) {} + /// The destructor. + inline ~QuaZipFilePrivate() + { + if (internal) + delete zip; + } +}; + QuaZipFile::QuaZipFile(): - zip(NULL), internal(true), zipError(UNZ_OK) + p(new QuaZipFilePrivate(this)) { } QuaZipFile::QuaZipFile(QObject *parent): - QIODevice(parent), zip(NULL), internal(true), zipError(UNZ_OK) + QIODevice(parent), + p(new QuaZipFilePrivate(this)) { } QuaZipFile::QuaZipFile(const QString& zipName, QObject *parent): - QIODevice(parent), internal(true), zipError(UNZ_OK) + QIODevice(parent), + p(new QuaZipFilePrivate(this, zipName)) { - zip=new QuaZip(zipName); - Q_CHECK_PTR(zip); } QuaZipFile::QuaZipFile(const QString& zipName, const QString& fileName, QuaZip::CaseSensitivity cs, QObject *parent): - QIODevice(parent), internal(true), zipError(UNZ_OK) + QIODevice(parent), + p(new QuaZipFilePrivate(this, zipName, fileName, cs)) { - zip=new QuaZip(zipName); - Q_CHECK_PTR(zip); - this->fileName=fileName; - this->caseSensitivity=cs; } QuaZipFile::QuaZipFile(QuaZip *zip, QObject *parent): QIODevice(parent), - zip(zip), internal(false), - zipError(UNZ_OK) + p(new QuaZipFilePrivate(this, zip)) { } QuaZipFile::~QuaZipFile() { - if(isOpen()) close(); - if(internal) delete zip; + if (isOpen()) + close(); + delete p; +} + +QString QuaZipFile::getZipName() const +{ + return p->zip==NULL ? QString() : p->zip->getZipName(); } -QString QuaZipFile::getZipName()const +QuaZip *QuaZipFile::getZip() const { - return zip==NULL?QString():zip->getZipName(); + return p->internal ? NULL : p->zip; } QString QuaZipFile::getActualFileName()const { - setZipError(UNZ_OK); - if(zip==NULL||(openMode()&WriteOnly)) return QString(); - QString name=zip->getCurrentFileName(); + p->setZipError(UNZ_OK); + if (p->zip == NULL || (openMode() & WriteOnly)) + return QString(); + QString name=p->zip->getCurrentFileName(); if(name.isNull()) - setZipError(zip->getZipError()); + p->setZipError(p->zip->getZipError()); return name; } @@ -95,10 +169,10 @@ void QuaZipFile::setZipName(const QString& zipName) qWarning("QuaZipFile::setZipName(): file is already open - can not set ZIP name"); return; } - if(zip!=NULL&&internal) delete zip; - zip=new QuaZip(zipName); - Q_CHECK_PTR(zip); - internal=true; + if(p->zip!=NULL && p->internal) + delete p->zip; + p->zip=new QuaZip(zipName); + p->internal=true; } void QuaZipFile::setZip(QuaZip *zip) @@ -107,19 +181,20 @@ void QuaZipFile::setZip(QuaZip *zip) qWarning("QuaZipFile::setZip(): file is already open - can not set ZIP"); return; } - if(this->zip!=NULL&&internal) delete this->zip; - this->zip=zip; - this->fileName=QString(); - internal=false; + if(p->zip!=NULL && p->internal) + delete p->zip; + p->zip=zip; + p->fileName=QString(); + p->internal=false; } void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs) { - if(zip==NULL) { + if(p->zip==NULL) { qWarning("QuaZipFile::setFileName(): call setZipName() first"); return; } - if(!internal) { + if(!p->internal) { qWarning("QuaZipFile::setFileName(): should not be used when not using internal QuaZip"); return; } @@ -127,18 +202,20 @@ void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs qWarning("QuaZipFile::setFileName(): can not set file name for already opened file"); return; } - this->fileName=fileName; - this->caseSensitivity=cs; + p->fileName=fileName; + if (p->fileName.startsWith('/')) + p->fileName = p->fileName.mid(1); + p->caseSensitivity=cs; } -void QuaZipFile::setZipError(int zipError)const +void QuaZipFilePrivate::setZipError(int zipError) const { - QuaZipFile *fakeThis=(QuaZipFile*)this; // non-const + QuaZipFilePrivate *fakeThis = const_cast(this); // non-const fakeThis->zipError=zipError; if(zipError==UNZ_OK) - fakeThis->setErrorString(QString()); + q->setErrorString(QString()); else - fakeThis->setErrorString(tr("ZIP/UNZIP API error %1").arg(zipError)); + q->setErrorString(QuaZipFile::tr("ZIP/UNZIP API error %1").arg(zipError)); } bool QuaZipFile::open(OpenMode mode) @@ -148,7 +225,7 @@ bool QuaZipFile::open(OpenMode mode) bool QuaZipFile::open(OpenMode mode, int *method, int *level, bool raw, const char *password) { - resetZipError(); + p->resetZipError(); if(isOpen()) { qWarning("QuaZipFile::open(): already opened"); return false; @@ -158,35 +235,35 @@ bool QuaZipFile::open(OpenMode mode, int *method, int *level, bool raw, const ch return false; } if((mode&ReadOnly)&&!(mode&WriteOnly)) { - if(internal) { - if(!zip->open(QuaZip::mdUnzip)) { - setZipError(zip->getZipError()); + if(p->internal) { + if(!p->zip->open(QuaZip::mdUnzip)) { + p->setZipError(p->zip->getZipError()); return false; } - if(!zip->setCurrentFile(fileName, caseSensitivity)) { - setZipError(zip->getZipError()); - zip->close(); + if(!p->zip->setCurrentFile(p->fileName, p->caseSensitivity)) { + p->setZipError(p->zip->getZipError()); + p->zip->close(); return false; } } else { - if(zip==NULL) { + if(p->zip==NULL) { qWarning("QuaZipFile::open(): zip is NULL"); return false; } - if(zip->getMode()!=QuaZip::mdUnzip) { + if(p->zip->getMode()!=QuaZip::mdUnzip) { qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d", - (int)mode, (int)zip->getMode()); + (int)mode, (int)p->zip->getMode()); return false; } - if(!zip->hasCurrentFile()) { + if(!p->zip->hasCurrentFile()) { qWarning("QuaZipFile::open(): zip does not have current file"); return false; } } - setZipError(unzOpenCurrentFile3(zip->getUnzFile(), method, level, (int)raw, password)); - if(zipError==UNZ_OK) { + p->setZipError(unzOpenCurrentFile3(p->zip->getUnzFile(), method, level, (int)raw, password)); + if(p->zipError==UNZ_OK) { setOpenMode(mode); - this->raw=raw; + p->raw=raw; return true; } else return false; @@ -201,23 +278,23 @@ bool QuaZipFile::open(OpenMode mode, const QuaZipNewInfo& info, int windowBits, int memLevel, int strategy) { zip_fileinfo info_z; - resetZipError(); + p->resetZipError(); if(isOpen()) { qWarning("QuaZipFile::open(): already opened"); return false; } if((mode&WriteOnly)&&!(mode&ReadOnly)) { - if(internal) { + if(p->internal) { qWarning("QuaZipFile::open(): write mode is incompatible with internal QuaZip approach"); return false; } - if(zip==NULL) { + if(p->zip==NULL) { qWarning("QuaZipFile::open(): zip is NULL"); return false; } - if(zip->getMode()!=QuaZip::mdCreate&&zip->getMode()!=QuaZip::mdAppend&&zip->getMode()!=QuaZip::mdAdd) { + if(p->zip->getMode()!=QuaZip::mdCreate&&p->zip->getMode()!=QuaZip::mdAppend&&p->zip->getMode()!=QuaZip::mdAdd) { qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d", - (int)mode, (int)zip->getMode()); + (int)mode, (int)p->zip->getMode()); return false; } info_z.tmz_date.tm_year=info.dateTime.date().year(); @@ -229,21 +306,25 @@ bool QuaZipFile::open(OpenMode mode, const QuaZipNewInfo& info, info_z.dosDate = 0; info_z.internal_fa=(uLong)info.internalAttr; info_z.external_fa=(uLong)info.externalAttr; - setZipError(zipOpenNewFileInZip3(zip->getZipFile(), - zip->getFileNameCodec()->fromUnicode(info.name).constData(), &info_z, + if (p->zip->isDataDescriptorWritingEnabled()) + zipSetFlags(p->zip->getZipFile(), ZIP_WRITE_DATA_DESCRIPTOR); + else + zipClearFlags(p->zip->getZipFile(), ZIP_WRITE_DATA_DESCRIPTOR); + p->setZipError(zipOpenNewFileInZip3_64(p->zip->getZipFile(), + p->zip->getFileNameCodec()->fromUnicode(info.name).constData(), &info_z, info.extraLocal.constData(), info.extraLocal.length(), info.extraGlobal.constData(), info.extraGlobal.length(), - zip->getCommentCodec()->fromUnicode(info.comment).constData(), + p->zip->getCommentCodec()->fromUnicode(info.comment).constData(), method, level, (int)raw, windowBits, memLevel, strategy, - password, (uLong)crc)); - if(zipError==UNZ_OK) { - writePos=0; + password, (uLong)crc, p->zip->isZip64Enabled())); + if(p->zipError==UNZ_OK) { + p->writePos=0; setOpenMode(mode); - this->raw=raw; + p->raw=raw; if(raw) { - this->crc=crc; - this->uncompressedSize=info.uncompressedSize; + p->crc=crc; + p->uncompressedSize=info.uncompressedSize; } return true; } else @@ -260,7 +341,7 @@ bool QuaZipFile::isSequential()const qint64 QuaZipFile::pos()const { - if(zip==NULL) { + if(p->zip==NULL) { qWarning("QuaZipFile::pos(): call setZipName() or setZip() first"); return -1; } @@ -269,14 +350,17 @@ qint64 QuaZipFile::pos()const return -1; } if(openMode()&ReadOnly) - return unztell(zip->getUnzFile()); + // QIODevice::pos() is broken for sequential devices, + // but thankfully bytesAvailable() returns the number of + // bytes buffered, so we know how far ahead we are. + return unztell(p->zip->getUnzFile()) - QIODevice::bytesAvailable(); else - return writePos; + return p->writePos; } bool QuaZipFile::atEnd()const { - if(zip==NULL) { + if(p->zip==NULL) { qWarning("QuaZipFile::atEnd(): call setZipName() or setZip() first"); return false; } @@ -285,7 +369,9 @@ bool QuaZipFile::atEnd()const return false; } if(openMode()&ReadOnly) - return unzeof(zip->getUnzFile())==1; + // the same problem as with pos() + return QIODevice::bytesAvailable() == 0 + && unzeof(p->zip->getUnzFile())==1; else return true; } @@ -297,81 +383,120 @@ qint64 QuaZipFile::size()const return -1; } if(openMode()&ReadOnly) - return raw?csize():usize(); + return p->raw?csize():usize(); else - return writePos; + return p->writePos; } qint64 QuaZipFile::csize()const { - unz_file_info info_z; - setZipError(UNZ_OK); - if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1; - setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); - if(zipError!=UNZ_OK) + unz_file_info64 info_z; + p->setZipError(UNZ_OK); + if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1; + p->setZipError(unzGetCurrentFileInfo64(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); + if(p->zipError!=UNZ_OK) return -1; return info_z.compressed_size; } qint64 QuaZipFile::usize()const { - unz_file_info info_z; - setZipError(UNZ_OK); - if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1; - setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); - if(zipError!=UNZ_OK) + unz_file_info64 info_z; + p->setZipError(UNZ_OK); + if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1; + p->setZipError(unzGetCurrentFileInfo64(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); + if(p->zipError!=UNZ_OK) return -1; return info_z.uncompressed_size; } bool QuaZipFile::getFileInfo(QuaZipFileInfo *info) { - if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return false; - zip->getCurrentFileInfo(info); - setZipError(zip->getZipError()); - return zipError==UNZ_OK; + QuaZipFileInfo64 info64; + if (getFileInfo(&info64)) { + info64.toQuaZipFileInfo(*info); + return true; + } else { + return false; + } +} + +bool QuaZipFile::getFileInfo(QuaZipFileInfo64 *info) +{ + if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return false; + p->zip->getCurrentFileInfo(info); + p->setZipError(p->zip->getZipError()); + return p->zipError==UNZ_OK; } void QuaZipFile::close() { - resetZipError(); - if(zip==NULL||!zip->isOpen()) return; + p->resetZipError(); + if(p->zip==NULL||!p->zip->isOpen()) return; if(!isOpen()) { qWarning("QuaZipFile::close(): file isn't open"); return; } if(openMode()&ReadOnly) - setZipError(unzCloseCurrentFile(zip->getUnzFile())); + p->setZipError(unzCloseCurrentFile(p->zip->getUnzFile())); else if(openMode()&WriteOnly) - if(isRaw()) setZipError(zipCloseFileInZipRaw(zip->getZipFile(), uncompressedSize, crc)); - else setZipError(zipCloseFileInZip(zip->getZipFile())); + if(isRaw()) p->setZipError(zipCloseFileInZipRaw64(p->zip->getZipFile(), p->uncompressedSize, p->crc)); + else p->setZipError(zipCloseFileInZip(p->zip->getZipFile())); else { qWarning("Wrong open mode: %d", (int)openMode()); return; } - if(zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen); + if(p->zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen); else return; - if(internal) { - zip->close(); - setZipError(zip->getZipError()); + if(p->internal) { + p->zip->close(); + p->setZipError(p->zip->getZipError()); } } qint64 QuaZipFile::readData(char *data, qint64 maxSize) { - setZipError(UNZ_OK); - qint64 bytesRead=unzReadCurrentFile(zip->getUnzFile(), data, (unsigned)maxSize); - if(bytesRead<0) setZipError((int)bytesRead); + p->setZipError(UNZ_OK); + qint64 bytesRead=unzReadCurrentFile(p->zip->getUnzFile(), data, (unsigned)maxSize); + if (bytesRead < 0) { + p->setZipError((int) bytesRead); + return -1; + } return bytesRead; } qint64 QuaZipFile::writeData(const char* data, qint64 maxSize) { - setZipError(ZIP_OK); - setZipError(zipWriteInFileInZip(zip->getZipFile(), data, (uint)maxSize)); - if(zipError!=ZIP_OK) return -1; + p->setZipError(ZIP_OK); + p->setZipError(zipWriteInFileInZip(p->zip->getZipFile(), data, (uint)maxSize)); + if(p->zipError!=ZIP_OK) return -1; else { - writePos+=maxSize; + p->writePos+=maxSize; return maxSize; } } + +QString QuaZipFile::getFileName() const +{ + return p->fileName; +} + +QuaZip::CaseSensitivity QuaZipFile::getCaseSensitivity() const +{ + return p->caseSensitivity; +} + +bool QuaZipFile::isRaw() const +{ + return p->raw; +} + +int QuaZipFile::getZipError() const +{ + return p->zipError; +} + +qint64 QuaZipFile::bytesAvailable() const +{ + return size() - pos(); +} diff --git a/rbutil/rbutilqt/quazip/quazipfile.h b/rbutil/rbutilqt/quazip/quazipfile.h index 09af5bceca..e27b7a4a6c 100644 --- a/rbutil/rbutilqt/quazip/quazipfile.h +++ b/rbutil/rbutilqt/quazip/quazipfile.h @@ -2,42 +2,37 @@ #define QUA_ZIPFILE_H /* --- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2008 Sergey A. Tachenov +Copyright (C) 2005-2014 Sergey A. Tachenov -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. +This file is part of QuaZIP. -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. --- A kind of "standard" GPL license statement ends here -- +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . -See COPYING file for GPL. +See COPYING file for the full LGPL text. -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. +Original ZIP package is copyrighted by Gilles Vollant, see +quazip/(un)zip.h files for details, basically it's zlib license. **/ #include +#include "quazip_global.h" #include "quazip.h" #include "quazipnewinfo.h" +class QuaZipFilePrivate; + /// A file inside ZIP archive. /** \class QuaZipFile quazipfile.h * This is the most interesting class. Not only it provides C++ @@ -51,6 +46,14 @@ QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. * it will create internal QuaZip object. See constructors' descriptions * for details. Writing is only possible with the existing instance. * + * Note that due to the underlying library's limitation it is not + * possible to use multiple QuaZipFile instances to open several files + * in the same archive at the same time. If you need to write to + * multiple files in parallel, then you should write to temporary files + * first, then pack them all at once when you have finished writing. If + * you need to read multiple files inside the same archive in parallel, + * you should extract them all into a temporary directory first. + * * \section quazipfile-sequential Sequential or random-access? * * At the first thought, QuaZipFile has fixed size, the start and the @@ -58,7 +61,7 @@ QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. * there is one major obstacle to making it random-access: ZIP/UNZIP API * does not support seek() operation and the only way to implement it is * through reopening the file and re-reading to the required position, - * but this is prohibitely slow. + * but this is prohibitively slow. * * Therefore, QuaZipFile is considered to be a sequential device. This * has advantage of availability of the ungetChar() operation (QIODevice @@ -68,25 +71,14 @@ QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. * this class. * **/ -class QuaZipFile: public QIODevice { +class QUAZIP_EXPORT QuaZipFile: public QIODevice { + friend class QuaZipFilePrivate; Q_OBJECT private: - QuaZip *zip; - QString fileName; - QuaZip::CaseSensitivity caseSensitivity; - bool raw; - qint64 writePos; - // these two are for writing raw files - ulong uncompressedSize; - quint32 crc; - bool internal; - int zipError; + QuaZipFilePrivate *p; // these are not supported nor implemented QuaZipFile(const QuaZipFile& that); QuaZipFile& operator=(const QuaZipFile& that); - void resetZipError()const {setZipError(UNZ_OK);} - // const, but sets zipError! - void setZipError(int zipError)const; protected: /// Implementation of the QIODevice::readData(). qint64 readData(char *data, qint64 maxSize); @@ -212,7 +204,7 @@ class QuaZipFile: public QIODevice { * * \sa getActualFileName **/ - QString getFileName()const {return fileName;} + QString getFileName() const; /// Returns case sensitivity of the file name. /** This function returns case sensitivity argument you passed to * this object either by using @@ -225,7 +217,7 @@ class QuaZipFile: public QIODevice { * * \sa getFileName **/ - QuaZip::CaseSensitivity getCaseSensitivity()const {return caseSensitivity;} + QuaZip::CaseSensitivity getCaseSensitivity() const; /// Returns the actual file name in the archive. /** This is \em not a ZIP archive file name, but a name of file inside * archive. It is not necessary the same name that you have passed @@ -265,7 +257,7 @@ class QuaZipFile: public QIODevice { * * \sa open(OpenMode,int*,int*,bool,const char*) **/ - bool isRaw()const {return raw;} + bool isRaw() const; /// Binds to the existing QuaZip instance. /** This function destroys internal QuaZip object, if any, and makes * this QuaZipFile to use current file in the \a zip object for any @@ -303,7 +295,7 @@ class QuaZipFile: public QIODevice { * Argument \a password specifies a password to decrypt the file. If * it is NULL then this function behaves just like open(OpenMode). **/ - bool open(OpenMode mode, const char *password) + inline bool open(OpenMode mode, const char *password) {return open(mode, NULL, NULL, false, password);} /// Opens a file for reading. /** \overload @@ -324,14 +316,21 @@ class QuaZipFile: public QIODevice { * specify correct timestamp (by default, current time will be * used). See QuaZipNewInfo. * - * Arguments \a password and \a crc provide necessary information - * for crypting. Note that you should specify both of them if you - * need crypting. If you do not, pass \c NULL as password, but you - * still need to specify \a crc if you are going to use raw mode - * (see below). + * The \a password argument specifies the password for crypting. Pass NULL + * if you don't need any crypting. The \a crc argument was supposed + * to be used for crypting too, but then it turned out that it's + * false information, so you need to set it to 0 unless you want to + * use the raw mode (see below). * * Arguments \a method and \a level specify compression method and - * level. + * level. The only method supported is Z_DEFLATED, but you may also + * specify 0 for no compression. If all of the files in the archive + * use both method 0 and either level 0 is explicitly specified or + * data descriptor writing is disabled with + * QuaZip::setDataDescriptorWritingEnabled(), then the + * resulting archive is supposed to be compatible with the 1.0 ZIP + * format version, should you need that. Except for this, \a level + * has no other effects with method 0. * * If \a raw is \c true, no compression is performed. In this case, * \a crc and uncompressedSize field of the \a info are required. @@ -428,15 +427,30 @@ class QuaZipFile: public QIODevice { * * File must be open for reading before calling this function. * - * Returns \c false in the case of an error. + * \return \c false in the case of an error. + * + * This function doesn't support zip64, but will still work fine on zip64 + * archives if file sizes are below 4 GB, otherwise the values will be set + * as if converted using QuaZipFileInfo64::toQuaZipFileInfo(). + * + * \sa getFileInfo(QuaZipFileInfo64*) **/ bool getFileInfo(QuaZipFileInfo *info); + /// Gets information about current file with zip64 support. + /** + * @overload + * + * \sa getFileInfo(QuaZipFileInfo*) + */ + bool getFileInfo(QuaZipFileInfo64 *info); /// Closes the file. /** Call getZipError() to determine if the close was successful. **/ virtual void close(); /// Returns the error code returned by the last ZIP/UNZIP API call. - int getZipError()const {return zipError;} + int getZipError() const; + /// Returns the number of bytes available for reading. + virtual qint64 bytesAvailable() const; }; #endif diff --git a/rbutil/rbutilqt/quazip/quazipfileinfo.cpp b/rbutil/rbutilqt/quazip/quazipfileinfo.cpp new file mode 100644 index 0000000000..f11c91017c --- /dev/null +++ b/rbutil/rbutilqt/quazip/quazipfileinfo.cpp @@ -0,0 +1,176 @@ +/* +Copyright (C) 2005-2014 Sergey A. Tachenov + +This file is part of QuaZIP. + +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. + +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant and contributors, +see quazip/(un)zip.h files for details. Basically it's the zlib license. +*/ + +#include "quazipfileinfo.h" + +static QFile::Permissions permissionsFromExternalAttr(quint32 externalAttr) { + quint32 uPerm = (externalAttr & 0xFFFF0000u) >> 16; + QFile::Permissions perm = 0; + if ((uPerm & 0400) != 0) + perm |= QFile::ReadOwner; + if ((uPerm & 0200) != 0) + perm |= QFile::WriteOwner; + if ((uPerm & 0100) != 0) + perm |= QFile::ExeOwner; + if ((uPerm & 0040) != 0) + perm |= QFile::ReadGroup; + if ((uPerm & 0020) != 0) + perm |= QFile::WriteGroup; + if ((uPerm & 0010) != 0) + perm |= QFile::ExeGroup; + if ((uPerm & 0004) != 0) + perm |= QFile::ReadOther; + if ((uPerm & 0002) != 0) + perm |= QFile::WriteOther; + if ((uPerm & 0001) != 0) + perm |= QFile::ExeOther; + return perm; + +} + +QFile::Permissions QuaZipFileInfo::getPermissions() const +{ + return permissionsFromExternalAttr(externalAttr); +} + +QFile::Permissions QuaZipFileInfo64::getPermissions() const +{ + return permissionsFromExternalAttr(externalAttr); +} + +bool QuaZipFileInfo64::toQuaZipFileInfo(QuaZipFileInfo &info) const +{ + bool noOverflow = true; + info.name = name; + info.versionCreated = versionCreated; + info.versionNeeded = versionNeeded; + info.flags = flags; + info.method = method; + info.dateTime = dateTime; + info.crc = crc; + if (compressedSize > 0xFFFFFFFFu) { + info.compressedSize = 0xFFFFFFFFu; + noOverflow = false; + } else { + info.compressedSize = compressedSize; + } + if (uncompressedSize > 0xFFFFFFFFu) { + info.uncompressedSize = 0xFFFFFFFFu; + noOverflow = false; + } else { + info.uncompressedSize = uncompressedSize; + } + info.diskNumberStart = diskNumberStart; + info.internalAttr = internalAttr; + info.externalAttr = externalAttr; + info.comment = comment; + info.extra = extra; + return noOverflow; +} + +static QDateTime getNTFSTime(const QByteArray &extra, int position, + int *fineTicks) +{ + QDateTime dateTime; + for (int i = 0; i <= extra.size() - 4; ) { + unsigned type = static_cast(static_cast( + extra.at(i))) + | (static_cast(static_cast( + extra.at(i + 1))) << 8); + i += 2; + unsigned length = static_cast(static_cast( + extra.at(i))) + | (static_cast(static_cast( + extra.at(i + 1))) << 8); + i += 2; + if (type == QUAZIP_EXTRA_NTFS_MAGIC && length >= 32) { + i += 4; // reserved + while (i <= extra.size() - 4) { + unsigned tag = static_cast( + static_cast(extra.at(i))) + | (static_cast( + static_cast(extra.at(i + 1))) + << 8); + i += 2; + int tagsize = static_cast( + static_cast(extra.at(i))) + | (static_cast( + static_cast(extra.at(i + 1))) + << 8); + i += 2; + if (tag == QUAZIP_EXTRA_NTFS_TIME_MAGIC + && tagsize >= position + 8) { + i += position; + quint64 mtime = static_cast( + static_cast(extra.at(i))) + | (static_cast(static_cast( + extra.at(i + 1))) << 8) + | (static_cast(static_cast( + extra.at(i + 2))) << 16) + | (static_cast(static_cast( + extra.at(i + 3))) << 24) + | (static_cast(static_cast( + extra.at(i + 4))) << 32) + | (static_cast(static_cast( + extra.at(i + 5))) << 40) + | (static_cast(static_cast( + extra.at(i + 6))) << 48) + | (static_cast(static_cast( + extra.at(i + 7))) << 56); + // the NTFS time is measured from 1601 for whatever reason + QDateTime base(QDate(1601, 1, 1), QTime(0, 0), Qt::UTC); + dateTime = base.addMSecs(mtime / 10000); + if (fineTicks != NULL) { + *fineTicks = static_cast(mtime % 10000); + } + i += tagsize - position; + } else { + i += tagsize; + } + + } + } else { + i += length; + } + } + if (fineTicks != NULL && dateTime.isNull()) { + *fineTicks = 0; + } + return dateTime; +} + +QDateTime QuaZipFileInfo64::getNTFSmTime(int *fineTicks) const +{ + return getNTFSTime(extra, 0, fineTicks); +} + +QDateTime QuaZipFileInfo64::getNTFSaTime(int *fineTicks) const +{ + return getNTFSTime(extra, 8, fineTicks); +} + +QDateTime QuaZipFileInfo64::getNTFScTime(int *fineTicks) const +{ + return getNTFSTime(extra, 16, fineTicks); +} diff --git a/rbutil/rbutilqt/quazip/quazipfileinfo.h b/rbutil/rbutilqt/quazip/quazipfileinfo.h index 3216d776d5..4e142a4eb5 100644 --- a/rbutil/rbutilqt/quazip/quazipfileinfo.h +++ b/rbutil/rbutilqt/quazip/quazipfileinfo.h @@ -2,44 +2,43 @@ #define QUA_ZIPFILEINFO_H /* --- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2007 Sergey A. Tachenov +Copyright (C) 2005-2014 Sergey A. Tachenov -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. +This file is part of QuaZIP. -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. --- A kind of "standard" GPL license statement ends here -- +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . -See COPYING file for GPL. +See COPYING file for the full LGPL text. -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. - **/ +Original ZIP package is copyrighted by Gilles Vollant and contributors, +see quazip/(un)zip.h files for details. Basically it's the zlib license. +*/ #include #include +#include + +#include "quazip_global.h" /// Information about a file inside archive. -/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to +/** + * \deprecated Use QuaZipFileInfo64 instead. Not only it supports large files, + * but also more convenience methods as well. + * + * Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to * fill this structure. */ -struct QuaZipFileInfo { +struct QUAZIP_EXPORT QuaZipFileInfo { /// File name. QString name; /// Version created by. @@ -68,6 +67,112 @@ struct QuaZipFileInfo { QString comment; /// Extra field. QByteArray extra; + /// Get the file permissions. + /** + Returns the high 16 bits of external attributes converted to + QFile::Permissions. + */ + QFile::Permissions getPermissions() const; +}; + +/// Information about a file inside archive (with zip64 support). +/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to + * fill this structure. */ +struct QUAZIP_EXPORT QuaZipFileInfo64 { + /// File name. + QString name; + /// Version created by. + quint16 versionCreated; + /// Version needed to extract. + quint16 versionNeeded; + /// General purpose flags. + quint16 flags; + /// Compression method. + quint16 method; + /// Last modification date and time. + /** + * This is the time stored in the standard ZIP header. This format only allows + * to store time with 2-second precision, so the seconds will always be even + * and the milliseconds will always be zero. If you need more precise + * date and time, you can try to call the getNTFSmTime() function or + * its siblings, provided that the archive itself contains these NTFS times. + */ + QDateTime dateTime; + /// CRC. + quint32 crc; + /// Compressed file size. + quint64 compressedSize; + /// Uncompressed file size. + quint64 uncompressedSize; + /// Disk number start. + quint16 diskNumberStart; + /// Internal file attributes. + quint16 internalAttr; + /// External file attributes. + quint32 externalAttr; + /// Comment. + QString comment; + /// Extra field. + QByteArray extra; + /// Get the file permissions. + /** + Returns the high 16 bits of external attributes converted to + QFile::Permissions. + */ + QFile::Permissions getPermissions() const; + /// Converts to QuaZipFileInfo + /** + If any of the fields are greater than 0xFFFFFFFFu, they are set to + 0xFFFFFFFFu exactly, not just truncated. This function should be mainly used + for compatibility with the old code expecting QuaZipFileInfo, in the cases + when it's impossible or otherwise unadvisable (due to ABI compatibility + reasons, for example) to modify that old code to use QuaZipFileInfo64. + + \return \c true if all fields converted correctly, \c false if an overflow + occured. + */ + bool toQuaZipFileInfo(QuaZipFileInfo &info) const; + /// Returns the NTFS modification time + /** + * The getNTFS*Time() functions only work if there is an NTFS extra field + * present. Otherwise, they all return invalid null timestamps. + * @param fineTicks If not NULL, the fractional part of milliseconds returned + * there, measured in 100-nanosecond ticks. Will be set to + * zero if there is no NTFS extra field. + * @sa dateTime + * @sa getNTFSaTime() + * @sa getNTFScTime() + * @return The NTFS modification time, UTC + */ + QDateTime getNTFSmTime(int *fineTicks = NULL) const; + /// Returns the NTFS access time + /** + * The getNTFS*Time() functions only work if there is an NTFS extra field + * present. Otherwise, they all return invalid null timestamps. + * @param fineTicks If not NULL, the fractional part of milliseconds returned + * there, measured in 100-nanosecond ticks. Will be set to + * zero if there is no NTFS extra field. + * @sa dateTime + * @sa getNTFSmTime() + * @sa getNTFScTime() + * @return The NTFS access time, UTC + */ + QDateTime getNTFSaTime(int *fineTicks = NULL) const; + /// Returns the NTFS creation time + /** + * The getNTFS*Time() functions only work if there is an NTFS extra field + * present. Otherwise, they all return invalid null timestamps. + * @param fineTicks If not NULL, the fractional part of milliseconds returned + * there, measured in 100-nanosecond ticks. Will be set to + * zero if there is no NTFS extra field. + * @sa dateTime + * @sa getNTFSmTime() + * @sa getNTFSaTime() + * @return The NTFS creation time, UTC + */ + QDateTime getNTFScTime(int *fineTicks = NULL) const; + /// Checks whether the file is encrypted. + bool isEncrypted() const {return (flags & 1) != 0;} }; #endif diff --git a/rbutil/rbutilqt/quazip/quazipnewinfo.cpp b/rbutil/rbutilqt/quazip/quazipnewinfo.cpp index 17571f2fc8..02e01da9c5 100644 --- a/rbutil/rbutilqt/quazip/quazipnewinfo.cpp +++ b/rbutil/rbutilqt/quazip/quazipnewinfo.cpp @@ -1,53 +1,98 @@ -/* -- A kind of "standard" GPL license statement -- -QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package -Copyright (C) 2005-2007 Sergey A. Tachenov - -This program is free software; you can redistribute it and/or modify it -under the terms of the GNU General Public License as published by the -Free Software Foundation; either version 2 of the License, or (at your -option) any later version. - -This program is distributed in the hope that it will be useful, but -WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -Public License for more details. - -You should have received a copy of the GNU General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - --- A kind of "standard" GPL license statement ends here -- - -See COPYING file for GPL. - -You are also permitted to use QuaZIP under the terms of LGPL (see -COPYING.LGPL). You are free to choose either license, but please note -that QuaZIP makes use of Qt, which is not licensed under LGPL. So if -you are using Open Source edition of Qt, you therefore MUST use GPL for -your code based on QuaZIP, since it would be also based on Qt in this -case. If you are Qt commercial license owner, then you are free to use -QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. +/* +Copyright (C) 2005-2014 Sergey A. Tachenov + +This file is part of QuaZIP. + +QuaZIP is free software: you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation, either version 2.1 of the License, or +(at your option) any later version. + +QuaZIP is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License +along with QuaZIP. If not, see . + +See COPYING file for the full LGPL text. + +Original ZIP package is copyrighted by Gilles Vollant and contributors, +see quazip/(un)zip.h files for details. Basically it's the zlib license. */ #include #include "quazipnewinfo.h" +#include + +static void QuaZipNewInfo_setPermissions(QuaZipNewInfo *info, + QFile::Permissions perm, bool isDir) +{ + quint32 uPerm = isDir ? 0040000 : 0100000; + if ((perm & QFile::ReadOwner) != 0) + uPerm |= 0400; + if ((perm & QFile::WriteOwner) != 0) + uPerm |= 0200; + if ((perm & QFile::ExeOwner) != 0) + uPerm |= 0100; + if ((perm & QFile::ReadGroup) != 0) + uPerm |= 0040; + if ((perm & QFile::WriteGroup) != 0) + uPerm |= 0020; + if ((perm & QFile::ExeGroup) != 0) + uPerm |= 0010; + if ((perm & QFile::ReadOther) != 0) + uPerm |= 0004; + if ((perm & QFile::WriteOther) != 0) + uPerm |= 0002; + if ((perm & QFile::ExeOther) != 0) + uPerm |= 0001; + info->externalAttr = (info->externalAttr & ~0xFFFF0000u) | (uPerm << 16); +} + +template +void QuaZipNewInfo_init(QuaZipNewInfo &self, const FileInfo &existing) +{ + self.name = existing.name; + self.dateTime = existing.dateTime; + self.internalAttr = existing.internalAttr; + self.externalAttr = existing.externalAttr; + self.comment = existing.comment; + self.extraLocal = existing.extra; + self.extraGlobal = existing.extra; + self.uncompressedSize = existing.uncompressedSize; +} + +QuaZipNewInfo::QuaZipNewInfo(const QuaZipFileInfo &existing) +{ + QuaZipNewInfo_init(*this, existing); +} + +QuaZipNewInfo::QuaZipNewInfo(const QuaZipFileInfo64 &existing) +{ + QuaZipNewInfo_init(*this, existing); +} QuaZipNewInfo::QuaZipNewInfo(const QString& name): - name(name), dateTime(QDateTime::currentDateTime()), internalAttr(0), externalAttr(0) + name(name), dateTime(QDateTime::currentDateTime()), internalAttr(0), externalAttr(0), + uncompressedSize(0) { } QuaZipNewInfo::QuaZipNewInfo(const QString& name, const QString& file): - name(name), internalAttr(0), externalAttr(0) + name(name), internalAttr(0), externalAttr(0), uncompressedSize(0) { QFileInfo info(file); QDateTime lm = info.lastModified(); - if (!info.exists()) + if (!info.exists()) { dateTime = QDateTime::currentDateTime(); - else + } else { dateTime = lm; + QuaZipNewInfo_setPermissions(this, info.permissions(), info.isDir()); + } } void QuaZipNewInfo::setFileDateTime(const QString& file) @@ -57,3 +102,176 @@ void QuaZipNewInfo::setFileDateTime(const QString& file) if (info.exists()) dateTime = lm; } + +void QuaZipNewInfo::setFilePermissions(const QString &file) +{ + QFileInfo info = QFileInfo(file); + QFile::Permissions perm = info.permissions(); + QuaZipNewInfo_setPermissions(this, perm, info.isDir()); +} + +void QuaZipNewInfo::setPermissions(QFile::Permissions permissions) +{ + QuaZipNewInfo_setPermissions(this, permissions, name.endsWith('/')); +} + +void QuaZipNewInfo::setFileNTFSTimes(const QString &fileName) +{ + QFileInfo fi(fileName); + if (!fi.exists()) { + qWarning("QuaZipNewInfo::setFileNTFSTimes(): '%s' doesn't exist", + fileName.toUtf8().constData()); + return; + } + setFileNTFSmTime(fi.lastModified()); + setFileNTFSaTime(fi.lastRead()); + setFileNTFScTime(fi.created()); +} + +static void setNTFSTime(QByteArray &extra, const QDateTime &time, int position, + int fineTicks) { + int ntfsPos = -1, timesPos = -1; + unsigned ntfsLength = 0, ntfsTimesLength = 0; + for (int i = 0; i <= extra.size() - 4; ) { + unsigned type = static_cast(static_cast( + extra.at(i))) + | (static_cast(static_cast( + extra.at(i + 1))) << 8); + i += 2; + unsigned length = static_cast(static_cast( + extra.at(i))) + | (static_cast(static_cast( + extra.at(i + 1))) << 8); + i += 2; + if (type == QUAZIP_EXTRA_NTFS_MAGIC) { + ntfsPos = i - 4; // the beginning of the NTFS record + ntfsLength = length; + if (length <= 4) { + break; // no times in the NTFS record + } + i += 4; // reserved + while (i <= extra.size() - 4) { + unsigned tag = static_cast( + static_cast(extra.at(i))) + | (static_cast( + static_cast(extra.at(i + 1))) + << 8); + i += 2; + unsigned tagsize = static_cast( + static_cast(extra.at(i))) + | (static_cast( + static_cast(extra.at(i + 1))) + << 8); + i += 2; + if (tag == QUAZIP_EXTRA_NTFS_TIME_MAGIC) { + timesPos = i - 4; // the beginning of the NTFS times tag + ntfsTimesLength = tagsize; + break; + } else { + i += tagsize; + } + } + break; // I ain't going to search for yet another NTFS record! + } else { + i += length; + } + } + if (ntfsPos == -1) { + // No NTFS record, need to create one. + ntfsPos = extra.size(); + ntfsLength = 32; + extra.resize(extra.size() + 4 + ntfsLength); + // the NTFS record header + extra[ntfsPos] = static_cast(QUAZIP_EXTRA_NTFS_MAGIC); + extra[ntfsPos + 1] = static_cast(QUAZIP_EXTRA_NTFS_MAGIC >> 8); + extra[ntfsPos + 2] = 32; // the 2-byte size in LittleEndian + extra[ntfsPos + 3] = 0; + // zero the record + memset(extra.data() + ntfsPos + 4, 0, 32); + timesPos = ntfsPos + 8; + // now set the tag data + extra[timesPos] = static_cast(QUAZIP_EXTRA_NTFS_TIME_MAGIC); + extra[timesPos + 1] = static_cast(QUAZIP_EXTRA_NTFS_TIME_MAGIC + >> 8); + // the size: + extra[timesPos + 2] = 24; + extra[timesPos + 3] = 0; + ntfsTimesLength = 24; + } + if (timesPos == -1) { + // No time tag in the NTFS record, need to add one. + timesPos = ntfsPos + 4 + ntfsLength; + extra.resize(extra.size() + 28); + // Now we need to move the rest of the field + // (possibly zero bytes, but memmove() is OK with that). + // 0 ......... ntfsPos .. ntfsPos + 4 ... timesPos + //
+ memmove(extra.data() + timesPos + 28, extra.data() + timesPos, + extra.size() - 28 - timesPos); + ntfsLength += 28; + // now set the tag data + extra[timesPos] = static_cast(QUAZIP_EXTRA_NTFS_TIME_MAGIC); + extra[timesPos + 1] = static_cast(QUAZIP_EXTRA_NTFS_TIME_MAGIC + >> 8); + // the size: + extra[timesPos + 2] = 24; + extra[timesPos + 3] = 0; + // zero the record + memset(extra.data() + timesPos + 4, 0, 24); + ntfsTimesLength = 24; + } + if (ntfsTimesLength < 24) { + // Broken times field. OK, this is really unlikely, but just in case... + size_t timesEnd = timesPos + 4 + ntfsTimesLength; + extra.resize(extra.size() + (24 - ntfsTimesLength)); + // Move it! + // 0 ......... timesPos .... timesPos + 4 .. timesEnd + //