summaryrefslogtreecommitdiffstats
path: root/rbutil/rbutilqt/mspack
diff options
context:
space:
mode:
authorAmaury Pouly <amaury.pouly@gmail.com>2013-03-11 18:46:03 +0100
committerDominik Riebeling <Dominik.Riebeling@gmail.com>2013-11-04 22:14:17 +0100
commit739a7ae0e9acb27227f5473a003833ea5a9c97ef (patch)
tree81f6dfd81b4343745b21a6c00c286791827175e4 /rbutil/rbutilqt/mspack
parent27111d83be815602ac35354e6a8e4e158c5968f9 (diff)
downloadrockbox-739a7ae0e9acb27227f5473a003833ea5a9c97ef.tar.gz
rockbox-739a7ae0e9acb27227f5473a003833ea5a9c97ef.tar.bz2
rockbox-739a7ae0e9acb27227f5473a003833ea5a9c97ef.zip
Add libmspack to rbutil
Change-Id: I520c14131ec1e12013f106c13cba00aac058ad83 Reviewed-on: http://gerrit.rockbox.org/391 Reviewed-by: Dominik Riebeling <Dominik.Riebeling@gmail.com>
Diffstat (limited to 'rbutil/rbutilqt/mspack')
-rw-r--r--rbutil/rbutilqt/mspack/COPYING.LIB504
-rw-r--r--rbutil/rbutilqt/mspack/README.ROCKBOX6
-rw-r--r--rbutil/rbutilqt/mspack/cab.h127
-rw-r--r--rbutil/rbutilqt/mspack/cabc.c24
-rw-r--r--rbutil/rbutilqt/mspack/cabd.c1444
-rw-r--r--rbutil/rbutilqt/mspack/chm.h122
-rw-r--r--rbutil/rbutilqt/mspack/chmc.c24
-rw-r--r--rbutil/rbutilqt/mspack/chmd.c1346
-rw-r--r--rbutil/rbutilqt/mspack/des.h15
-rw-r--r--rbutil/rbutilqt/mspack/hlp.h33
-rw-r--r--rbutil/rbutilqt/mspack/hlpc.c24
-rw-r--r--rbutil/rbutilqt/mspack/hlpd.c24
-rw-r--r--rbutil/rbutilqt/mspack/kwaj.h118
-rw-r--r--rbutil/rbutilqt/mspack/kwajc.c24
-rw-r--r--rbutil/rbutilqt/mspack/kwajd.c555
-rw-r--r--rbutil/rbutilqt/mspack/lit.h35
-rw-r--r--rbutil/rbutilqt/mspack/litc.c24
-rw-r--r--rbutil/rbutilqt/mspack/litd.c24
-rw-r--r--rbutil/rbutilqt/mspack/lzss.h66
-rw-r--r--rbutil/rbutilqt/mspack/lzssd.c93
-rw-r--r--rbutil/rbutilqt/mspack/lzx.h194
-rw-r--r--rbutil/rbutilqt/mspack/lzxc.c18
-rw-r--r--rbutil/rbutilqt/mspack/lzxd.c738
-rw-r--r--rbutil/rbutilqt/mspack/mspack.h2203
-rw-r--r--rbutil/rbutilqt/mspack/mszip.h121
-rw-r--r--rbutil/rbutilqt/mspack/mszipc.c18
-rw-r--r--rbutil/rbutilqt/mspack/mszipd.c475
-rw-r--r--rbutil/rbutilqt/mspack/qtm.h128
-rw-r--r--rbutil/rbutilqt/mspack/qtmd.c489
-rw-r--r--rbutil/rbutilqt/mspack/readbits.h207
-rw-r--r--rbutil/rbutilqt/mspack/readhuff.h173
-rw-r--r--rbutil/rbutilqt/mspack/sha.h15
-rw-r--r--rbutil/rbutilqt/mspack/system.c237
-rw-r--r--rbutil/rbutilqt/mspack/system.h124
-rw-r--r--rbutil/rbutilqt/mspack/szdd.h39
-rw-r--r--rbutil/rbutilqt/mspack/szddc.c24
-rw-r--r--rbutil/rbutilqt/mspack/szddd.c247
37 files changed, 10082 insertions, 0 deletions
diff --git a/rbutil/rbutilqt/mspack/COPYING.LIB b/rbutil/rbutilqt/mspack/COPYING.LIB
new file mode 100644
index 0000000000..b1e3f5a263
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/COPYING.LIB
@@ -0,0 +1,504 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 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.
+
+[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
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. 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.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library 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.
+
+ This library 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 this library; 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.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/rbutil/rbutilqt/mspack/README.ROCKBOX b/rbutil/rbutilqt/mspack/README.ROCKBOX
new file mode 100644
index 0000000000..db5ba7f482
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/README.ROCKBOX
@@ -0,0 +1,6 @@
+This folder contains the mspack project for MS files compression/decompression.
+These files are distributed under the LGPL.
+The source files have been last synced with libmspack-0.3alpha
+http://sourceforge.net/projects/libmspack/on January 28, 2013
+
+
diff --git a/rbutil/rbutilqt/mspack/cab.h b/rbutil/rbutilqt/mspack/cab.h
new file mode 100644
index 0000000000..9f449d1f29
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/cab.h
@@ -0,0 +1,127 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_CAB_H
+#define MSPACK_CAB_H 1
+
+#include <mszip.h>
+#include <qtm.h>
+#include <lzx.h>
+
+/* generic CAB definitions */
+
+/* structure offsets */
+#define cfhead_Signature (0x00)
+#define cfhead_CabinetSize (0x08)
+#define cfhead_FileOffset (0x10)
+#define cfhead_MinorVersion (0x18)
+#define cfhead_MajorVersion (0x19)
+#define cfhead_NumFolders (0x1A)
+#define cfhead_NumFiles (0x1C)
+#define cfhead_Flags (0x1E)
+#define cfhead_SetID (0x20)
+#define cfhead_CabinetIndex (0x22)
+#define cfhead_SIZEOF (0x24)
+#define cfheadext_HeaderReserved (0x00)
+#define cfheadext_FolderReserved (0x02)
+#define cfheadext_DataReserved (0x03)
+#define cfheadext_SIZEOF (0x04)
+#define cffold_DataOffset (0x00)
+#define cffold_NumBlocks (0x04)
+#define cffold_CompType (0x06)
+#define cffold_SIZEOF (0x08)
+#define cffile_UncompressedSize (0x00)
+#define cffile_FolderOffset (0x04)
+#define cffile_FolderIndex (0x08)
+#define cffile_Date (0x0A)
+#define cffile_Time (0x0C)
+#define cffile_Attribs (0x0E)
+#define cffile_SIZEOF (0x10)
+#define cfdata_CheckSum (0x00)
+#define cfdata_CompressedSize (0x04)
+#define cfdata_UncompressedSize (0x06)
+#define cfdata_SIZEOF (0x08)
+
+/* flags */
+#define cffoldCOMPTYPE_MASK (0x000f)
+#define cffoldCOMPTYPE_NONE (0x0000)
+#define cffoldCOMPTYPE_MSZIP (0x0001)
+#define cffoldCOMPTYPE_QUANTUM (0x0002)
+#define cffoldCOMPTYPE_LZX (0x0003)
+#define cfheadPREV_CABINET (0x0001)
+#define cfheadNEXT_CABINET (0x0002)
+#define cfheadRESERVE_PRESENT (0x0004)
+#define cffileCONTINUED_FROM_PREV (0xFFFD)
+#define cffileCONTINUED_TO_NEXT (0xFFFE)
+#define cffileCONTINUED_PREV_AND_NEXT (0xFFFF)
+
+/* CAB data blocks are <= 32768 bytes in uncompressed form. Uncompressed
+ * blocks have zero growth. MSZIP guarantees that it won't grow above
+ * uncompressed size by more than 12 bytes. LZX guarantees it won't grow
+ * more than 6144 bytes. Quantum has no documentation, but the largest
+ * block seen in the wild is 337 bytes above uncompressed size.
+ */
+#define CAB_BLOCKMAX (32768)
+#define CAB_INPUTMAX (CAB_BLOCKMAX+6144)
+
+/* CAB compression definitions */
+
+struct mscab_compressor_p {
+ struct mscab_compressor base;
+ struct mspack_system *system;
+ /* todo */
+};
+
+/* CAB decompression definitions */
+
+struct mscabd_decompress_state {
+ struct mscabd_folder_p *folder; /* current folder we're extracting from */
+ struct mscabd_folder_data *data; /* current folder split we're in */
+ unsigned int offset; /* uncompressed offset within folder */
+ unsigned int block; /* which block are we decompressing? */
+ struct mspack_system sys; /* special I/O code for decompressor */
+ int comp_type; /* type of compression used by folder */
+ int (*decompress)(void *, off_t); /* decompressor code */
+ void *state; /* decompressor state */
+ struct mscabd_cabinet_p *incab; /* cabinet where input data comes from */
+ struct mspack_file *infh; /* input file handle */
+ struct mspack_file *outfh; /* output file handle */
+ unsigned char *i_ptr, *i_end; /* input data consumed, end */
+ unsigned char input[CAB_INPUTMAX]; /* one input block of data */
+};
+
+struct mscab_decompressor_p {
+ struct mscab_decompressor base;
+ struct mscabd_decompress_state *d;
+ struct mspack_system *system;
+ int param[3]; /* !!! MATCH THIS TO NUM OF PARAMS IN MSPACK.H !!! */
+ int error, read_error;
+};
+
+struct mscabd_cabinet_p {
+ struct mscabd_cabinet base;
+ off_t blocks_off; /* offset to data blocks */
+ int block_resv; /* reserved space in data blocks */
+};
+
+/* there is one of these for every cabinet a folder spans */
+struct mscabd_folder_data {
+ struct mscabd_folder_data *next;
+ struct mscabd_cabinet_p *cab; /* cabinet file of this folder span */
+ off_t offset; /* cabinet offset of first datablock */
+};
+
+struct mscabd_folder_p {
+ struct mscabd_folder base;
+ struct mscabd_folder_data data; /* where are the data blocks? */
+ struct mscabd_file *merge_prev; /* first file needing backwards merge */
+ struct mscabd_file *merge_next; /* first file needing forwards merge */
+};
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/cabc.c b/rbutil/rbutilqt/mspack/cabc.c
new file mode 100644
index 0000000000..242e0347c3
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/cabc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* CAB compression implementation */
+
+#include <system.h>
+#include <cab.h>
+
+struct mscab_compressor *
+ mspack_create_cab_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_cab_compressor(struct mscab_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/cabd.c b/rbutil/rbutilqt/mspack/cabd.c
new file mode 100644
index 0000000000..24ff2031f3
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/cabd.c
@@ -0,0 +1,1444 @@
+/* This file is part of libmspack.
+ * (C) 2003-2011 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* Cabinet (.CAB) files are a form of file archive. Each cabinet contains
+ * "folders", which are compressed spans of data. Each cabinet has
+ * "files", whose metadata is in the cabinet header, but whose actual data
+ * is stored compressed in one of the "folders". Cabinets can span more
+ * than one physical file on disk, in which case they are a "cabinet set",
+ * and usually the last folder of each cabinet extends into the next
+ * cabinet.
+ *
+ * For a complete description of the format, see the MSDN site:
+ * http://msdn.microsoft.com/en-us/library/bb267310.aspx
+ */
+
+/* CAB decompression implementation */
+
+#include <system.h>
+#include <cab.h>
+#include <assert.h>
+
+/* Notes on compliance with cabinet specification:
+ *
+ * One of the main changes between cabextract 0.6 and libmspack's cab
+ * decompressor is the move from block-oriented decompression to
+ * stream-oriented decompression.
+ *
+ * cabextract would read one data block from disk, decompress it with the
+ * appropriate method, then write the decompressed data. The CAB
+ * specification is specifically designed to work like this, as it ensures
+ * compression matches do not span the maximum decompressed block size
+ * limit of 32kb.
+ *
+ * However, the compression algorithms used are stream oriented, with
+ * specific hacks added to them to enforce the "individual 32kb blocks"
+ * rule in CABs. In other file formats, they do not have this limitation.
+ *
+ * In order to make more generalised decompressors, libmspack's CAB
+ * decompressor has moved from being block-oriented to more stream
+ * oriented. This also makes decompression slightly faster.
+ *
+ * However, this leads to incompliance with the CAB specification. The
+ * CAB controller can no longer ensure each block of input given to the
+ * decompressors is matched with their output. The "decompressed size" of
+ * each individual block is thrown away.
+ *
+ * Each CAB block is supposed to be seen as individually compressed. This
+ * means each consecutive data block can have completely different
+ * "uncompressed" sizes, ranging from 1 to 32768 bytes. However, in
+ * reality, all data blocks in a folder decompress to exactly 32768 bytes,
+ * excepting the final block.
+ *
+ * Given this situation, the decompression algorithms are designed to
+ * realign their input bitstreams on 32768 output-byte boundaries, and
+ * various other special cases have been made. libmspack will not
+ * correctly decompress LZX or Quantum compressed folders where the blocks
+ * do not follow this "32768 bytes until last block" pattern. It could be
+ * implemented if needed, but hopefully this is not necessary -- it has
+ * not been seen in over 3Gb of CAB archives.
+ */
+
+/* prototypes */
+static struct mscabd_cabinet * cabd_open(
+ struct mscab_decompressor *base, const char *filename);
+static void cabd_close(
+ struct mscab_decompressor *base, struct mscabd_cabinet *origcab);
+static int cabd_read_headers(
+ struct mspack_system *sys, struct mspack_file *fh,
+ struct mscabd_cabinet_p *cab, off_t offset, int quiet);
+static char *cabd_read_string(
+ struct mspack_system *sys, struct mspack_file *fh,
+ struct mscabd_cabinet_p *cab, int *error);
+
+static struct mscabd_cabinet *cabd_search(
+ struct mscab_decompressor *base, const char *filename);
+static int cabd_find(
+ struct mscab_decompressor_p *self, unsigned char *buf,
+ struct mspack_file *fh, const char *filename, off_t flen,
+ off_t *firstlen, struct mscabd_cabinet_p **firstcab);
+
+static int cabd_prepend(
+ struct mscab_decompressor *base, struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *prevcab);
+static int cabd_append(
+ struct mscab_decompressor *base, struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *nextcab);
+static int cabd_merge(
+ struct mscab_decompressor *base, struct mscabd_cabinet *lcab,
+ struct mscabd_cabinet *rcab);
+static int cabd_can_merge_folders(
+ struct mspack_system *sys, struct mscabd_folder_p *lfol,
+ struct mscabd_folder_p *rfol);
+
+static int cabd_extract(
+ struct mscab_decompressor *base, struct mscabd_file *file,
+ const char *filename);
+static int cabd_init_decomp(
+ struct mscab_decompressor_p *self, unsigned int ct);
+static void cabd_free_decomp(
+ struct mscab_decompressor_p *self);
+static int cabd_sys_read(
+ struct mspack_file *file, void *buffer, int bytes);
+static int cabd_sys_write(
+ struct mspack_file *file, void *buffer, int bytes);
+static int cabd_sys_read_block(
+ struct mspack_system *sys, struct mscabd_decompress_state *d, int *out,
+ int ignore_cksum);
+static unsigned int cabd_checksum(
+ unsigned char *data, unsigned int bytes, unsigned int cksum);
+static struct noned_state *noned_init(
+ struct mspack_system *sys, struct mspack_file *in, struct mspack_file *out,
+ int bufsize);
+
+static int noned_decompress(
+ struct noned_state *s, off_t bytes);
+static void noned_free(
+ struct noned_state *state);
+
+static int cabd_param(
+ struct mscab_decompressor *base, int param, int value);
+
+static int cabd_error(
+ struct mscab_decompressor *base);
+
+
+/***************************************
+ * MSPACK_CREATE_CAB_DECOMPRESSOR
+ ***************************************
+ * constructor
+ */
+struct mscab_decompressor *
+ mspack_create_cab_decompressor(struct mspack_system *sys)
+{
+ struct mscab_decompressor_p *self = NULL;
+
+ if (!sys) sys = mspack_default_system;
+ if (!mspack_valid_system(sys)) return NULL;
+
+ if ((self = (struct mscab_decompressor_p *) sys->alloc(sys, sizeof(struct mscab_decompressor_p)))) {
+ self->base.open = &cabd_open;
+ self->base.close = &cabd_close;
+ self->base.search = &cabd_search;
+ self->base.extract = &cabd_extract;
+ self->base.prepend = &cabd_prepend;
+ self->base.append = &cabd_append;
+ self->base.set_param = &cabd_param;
+ self->base.last_error = &cabd_error;
+ self->system = sys;
+ self->d = NULL;
+ self->error = MSPACK_ERR_OK;
+
+ self->param[MSCABD_PARAM_SEARCHBUF] = 32768;
+ self->param[MSCABD_PARAM_FIXMSZIP] = 0;
+ self->param[MSCABD_PARAM_DECOMPBUF] = 4096;
+ }
+ return (struct mscab_decompressor *) self;
+}
+
+/***************************************
+ * MSPACK_DESTROY_CAB_DECOMPRESSOR
+ ***************************************
+ * destructor
+ */
+void mspack_destroy_cab_decompressor(struct mscab_decompressor *base) {
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ if (self) {
+ struct mspack_system *sys = self->system;
+ cabd_free_decomp(self);
+ if (self->d) {
+ if (self->d->infh) sys->close(self->d->infh);
+ sys->free(self->d);
+ }
+ sys->free(self);
+ }
+}
+
+
+/***************************************
+ * CABD_OPEN
+ ***************************************
+ * opens a file and tries to read it as a cabinet file
+ */
+static struct mscabd_cabinet *cabd_open(struct mscab_decompressor *base,
+ const char *filename)
+{
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ struct mscabd_cabinet_p *cab = NULL;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+ int error;
+
+ if (!base) return NULL;
+ sys = self->system;
+
+ if ((fh = sys->open(sys, filename, MSPACK_SYS_OPEN_READ))) {
+ if ((cab = (struct mscabd_cabinet_p *) sys->alloc(sys, sizeof(struct mscabd_cabinet_p)))) {
+ cab->base.filename = filename;
+ error = cabd_read_headers(sys, fh, cab, (off_t) 0, 0);
+ if (error) {
+ cabd_close(base, (struct mscabd_cabinet *) cab);
+ cab = NULL;
+ }
+ self->error = error;
+ }
+ else {
+ self->error = MSPACK_ERR_NOMEMORY;
+ }
+ sys->close(fh);
+ }
+ else {
+ self->error = MSPACK_ERR_OPEN;
+ }
+ return (struct mscabd_cabinet *) cab;
+}
+
+/***************************************
+ * CABD_CLOSE
+ ***************************************
+ * frees all memory associated with a given mscabd_cabinet.
+ */
+static void cabd_close(struct mscab_decompressor *base,
+ struct mscabd_cabinet *origcab)
+{
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ struct mscabd_folder_data *dat, *ndat;
+ struct mscabd_cabinet *cab, *ncab;
+ struct mscabd_folder *fol, *nfol;
+ struct mscabd_file *fi, *nfi;
+ struct mspack_system *sys;
+
+ if (!base) return;
+ sys = self->system;
+
+ self->error = MSPACK_ERR_OK;
+
+ while (origcab) {
+ /* free files */
+ for (fi = origcab->files; fi; fi = nfi) {
+ nfi = fi->next;
+ sys->free(fi->filename);
+ sys->free(fi);
+ }
+
+ /* free folders */
+ for (fol = origcab->folders; fol; fol = nfol) {
+ nfol = fol->next;
+
+ /* free folder decompression state if it has been decompressed */
+ if (self->d && (self->d->folder == (struct mscabd_folder_p *) fol)) {
+ if (self->d->infh) sys->close(self->d->infh);
+ cabd_free_decomp(self);
+ sys->free(self->d);
+ self->d = NULL;
+ }
+
+ /* free folder data segments */
+ for (dat = ((struct mscabd_folder_p *)fol)->data.next; dat; dat = ndat) {
+ ndat = dat->next;
+ sys->free(dat);
+ }
+ sys->free(fol);
+ }
+
+ /* free predecessor cabinets (and the original cabinet's strings) */
+ for (cab = origcab; cab; cab = ncab) {
+ ncab = cab->prevcab;
+ sys->free(cab->prevname);
+ sys->free(cab->nextname);
+ sys->free(cab->previnfo);
+ sys->free(cab->nextinfo);
+ if (cab != origcab) sys->free(cab);
+ }
+
+ /* free successor cabinets */
+ for (cab = origcab->nextcab; cab; cab = ncab) {
+ ncab = cab->nextcab;
+ sys->free(cab->prevname);
+ sys->free(cab->nextname);
+ sys->free(cab->previnfo);
+ sys->free(cab->nextinfo);
+ sys->free(cab);
+ }
+
+ /* free actual cabinet structure */
+ cab = origcab->next;
+ sys->free(origcab);
+
+ /* repeat full procedure again with the cab->next pointer (if set) */
+ origcab = cab;
+ }
+}
+
+/***************************************
+ * CABD_READ_HEADERS
+ ***************************************
+ * reads the cabinet file header, folder list and file list.
+ * fills out a pre-existing mscabd_cabinet structure, allocates memory
+ * for folders and files as necessary
+ */
+static int cabd_read_headers(struct mspack_system *sys,
+ struct mspack_file *fh,
+ struct mscabd_cabinet_p *cab,
+ off_t offset, int quiet)
+{
+ int num_folders, num_files, folder_resv, i, x;
+ struct mscabd_folder_p *fol, *linkfol = NULL;
+ struct mscabd_file *file, *linkfile = NULL;
+ unsigned char buf[64];
+
+ /* initialise pointers */
+ cab->base.next = NULL;
+ cab->base.files = NULL;
+ cab->base.folders = NULL;
+ cab->base.prevcab = cab->base.nextcab = NULL;
+ cab->base.prevname = cab->base.nextname = NULL;
+ cab->base.previnfo = cab->base.nextinfo = NULL;
+
+ cab->base.base_offset = offset;
+
+ /* seek to CFHEADER */
+ if (sys->seek(fh, offset, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* read in the CFHEADER */
+ if (sys->read(fh, &buf[0], cfhead_SIZEOF) != cfhead_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* check for "MSCF" signature */
+ if (EndGetI32(&buf[cfhead_Signature]) != 0x4643534D) {
+ return MSPACK_ERR_SIGNATURE;
+ }
+
+ /* some basic header fields */
+ cab->base.length = EndGetI32(&buf[cfhead_CabinetSize]);
+ cab->base.set_id = EndGetI16(&buf[cfhead_SetID]);
+ cab->base.set_index = EndGetI16(&buf[cfhead_CabinetIndex]);
+
+ /* get the number of folders */
+ num_folders = EndGetI16(&buf[cfhead_NumFolders]);
+ if (num_folders == 0) {
+ if (!quiet) sys->message(fh, "no folders in cabinet.");
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* get the number of files */
+ num_files = EndGetI16(&buf[cfhead_NumFiles]);
+ if (num_files == 0) {
+ if (!quiet) sys->message(fh, "no files in cabinet.");
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* check cabinet version */
+ if ((buf[cfhead_MajorVersion] != 1) && (buf[cfhead_MinorVersion] != 3)) {
+ if (!quiet) sys->message(fh, "WARNING; cabinet version is not 1.3");
+ }
+
+ /* read the reserved-sizes part of header, if present */
+ cab->base.flags = EndGetI16(&buf[cfhead_Flags]);
+ if (cab->base.flags & cfheadRESERVE_PRESENT) {
+ if (sys->read(fh, &buf[0], cfheadext_SIZEOF) != cfheadext_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+ cab->base.header_resv = EndGetI16(&buf[cfheadext_HeaderReserved]);
+ folder_resv = buf[cfheadext_FolderReserved];
+ cab->block_resv = buf[cfheadext_DataReserved];
+
+ if (cab->base.header_resv > 60000) {
+ if (!quiet) sys->message(fh, "WARNING; reserved header > 60000.");
+ }
+
+ /* skip the reserved header */
+ if (cab->base.header_resv) {
+ if (sys->seek(fh, (off_t) cab->base.header_resv, MSPACK_SYS_SEEK_CUR)) {
+ return MSPACK_ERR_SEEK;
+ }
+ }
+ }
+ else {
+ cab->base.header_resv = 0;
+ folder_resv = 0;
+ cab->block_resv = 0;
+ }
+
+ /* read name and info of preceeding cabinet in set, if present */
+ if (cab->base.flags & cfheadPREV_CABINET) {
+ cab->base.prevname = cabd_read_string(sys, fh, cab, &x); if (x) return x;
+ cab->base.previnfo = cabd_read_string(sys, fh, cab, &x); if (x) return x;
+ }
+
+ /* read name and info of next cabinet in set, if present */
+ if (cab->base.flags & cfheadNEXT_CABINET) {
+ cab->base.nextname = cabd_read_string(sys, fh, cab, &x); if (x) return x;
+ cab->base.nextinfo = cabd_read_string(sys, fh, cab, &x); if (x) return x;
+ }
+
+ /* read folders */
+ for (i = 0; i < num_folders; i++) {
+ if (sys->read(fh, &buf[0], cffold_SIZEOF) != cffold_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+ if (folder_resv) {
+ if (sys->seek(fh, (off_t) folder_resv, MSPACK_SYS_SEEK_CUR)) {
+ return MSPACK_ERR_SEEK;
+ }
+ }
+
+ if (!(fol = (struct mscabd_folder_p *) sys->alloc(sys, sizeof(struct mscabd_folder_p)))) {
+ return MSPACK_ERR_NOMEMORY;
+ }
+ fol->base.next = NULL;
+ fol->base.comp_type = EndGetI16(&buf[cffold_CompType]);
+ fol->base.num_blocks = EndGetI16(&buf[cffold_NumBlocks]);
+ fol->data.next = NULL;
+ fol->data.cab = (struct mscabd_cabinet_p *) cab;
+ fol->data.offset = offset + (off_t)
+ ( (unsigned int) EndGetI32(&buf[cffold_DataOffset]) );
+ fol->merge_prev = NULL;
+ fol->merge_next = NULL;
+
+ /* link folder into list of folders */
+ if (!linkfol) cab->base.folders = (struct mscabd_folder *) fol;
+ else linkfol->base.next = (struct mscabd_folder *) fol;
+ linkfol = fol;
+ }
+
+ /* read files */
+ for (i = 0; i < num_files; i++) {
+ if (sys->read(fh, &buf[0], cffile_SIZEOF) != cffile_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ if (!(file = (struct mscabd_file *) sys->alloc(sys, sizeof(struct mscabd_file)))) {
+ return MSPACK_ERR_NOMEMORY;
+ }
+
+ file->next = NULL;
+ file->length = EndGetI32(&buf[cffile_UncompressedSize]);
+ file->attribs = EndGetI16(&buf[cffile_Attribs]);
+ file->offset = EndGetI32(&buf[cffile_FolderOffset]);
+
+ /* set folder pointer */
+ x = EndGetI16(&buf[cffile_FolderIndex]);
+ if (x < cffileCONTINUED_FROM_PREV) {
+ /* normal folder index; count up to the correct folder. the folder
+ * pointer will be NULL if folder index is invalid */
+ struct mscabd_folder *ifol = cab->base.folders;
+ while (x--) if (ifol) ifol = ifol->next;
+ file->folder = ifol;
+
+ if (!ifol) {
+ sys->free(file);
+ D(("invalid folder index"))
+ return MSPACK_ERR_DATAFORMAT;
+ }
+ }
+ else {
+ /* either CONTINUED_TO_NEXT, CONTINUED_FROM_PREV or
+ * CONTINUED_PREV_AND_NEXT */
+ if ((x == cffileCONTINUED_TO_NEXT) ||
+ (x == cffileCONTINUED_PREV_AND_NEXT))
+ {
+ /* get last folder */
+ struct mscabd_folder *ifol = cab->base.folders;
+ while (ifol->next) ifol = ifol->next;
+ file->folder = ifol;
+
+ /* set "merge next" pointer */
+ fol = (struct mscabd_folder_p *) ifol;
+ if (!fol->merge_next) fol->merge_next = file;
+ }
+
+ if ((x == cffileCONTINUED_FROM_PREV) ||
+ (x == cffileCONTINUED_PREV_AND_NEXT))
+ {
+ /* get first folder */
+ file->folder = cab->base.folders;
+
+ /* set "merge prev" pointer */
+ fol = (struct mscabd_folder_p *) file->folder;
+ if (!fol->merge_prev) fol->merge_prev = file;
+ }
+ }
+
+ /* get time */
+ x = EndGetI16(&buf[cffile_Time]);
+ file->time_h = x >> 11;
+ file->time_m = (x >> 5) & 0x3F;
+ file->time_s = (x << 1) & 0x3E;
+
+ /* get date */
+ x = EndGetI16(&buf[cffile_Date]);
+ file->date_d = x & 0x1F;
+ file->date_m = (x >> 5) & 0xF;
+ file->date_y = (x >> 9) + 1980;
+
+ /* get filename */
+ file->filename = cabd_read_string(sys, fh, cab, &x);
+ if (x) {
+ sys->free(file);
+ return x;
+ }
+
+ /* link file entry into file list */
+ if (!linkfile) cab->base.files = file;
+ else linkfile->next = file;
+ linkfile = file;
+ }
+
+ return MSPACK_ERR_OK;
+}
+
+static char *cabd_read_string(struct mspack_system *sys,
+ struct mspack_file *fh,
+ struct mscabd_cabinet_p *cab, int *error)
+{
+ off_t base = sys->tell(fh);
+ char buf[256], *str;
+ unsigned int len, i, ok;
+
+ /* read up to 256 bytes */
+ len = sys->read(fh, &buf[0], 256);
+
+ /* search for a null terminator in the buffer */
+ for (i = 0, ok = 0; i < len; i++) if (!buf[i]) { ok = 1; break; }
+ if (!ok) {
+ *error = MSPACK_ERR_DATAFORMAT;
+ return NULL;
+ }
+
+ len = i + 1;
+
+ /* set the data stream to just after the string and return */
+ if (sys->seek(fh, base + (off_t)len, MSPACK_SYS_SEEK_START)) {
+ *error = MSPACK_ERR_SEEK;
+ return NULL;
+ }
+
+ if (!(str = (char *) sys->alloc(sys, len))) {
+ *error = MSPACK_ERR_NOMEMORY;
+ return NULL;
+ }
+
+ sys->copy(&buf[0], str, len);
+ *error = MSPACK_ERR_OK;
+ return str;
+}
+
+/***************************************
+ * CABD_SEARCH, CABD_FIND
+ ***************************************
+ * cabd_search opens a file, finds its extent, allocates a search buffer,
+ * then reads through the whole file looking for possible cabinet headers.
+ * if it finds any, it tries to read them as real cabinets. returns a linked
+ * list of results
+ *
+ * cabd_find is the inner loop of cabd_search, to make it easier to
+ * break out of the loop and be sure that all resources are freed
+ */
+static struct mscabd_cabinet *cabd_search(struct mscab_decompressor *base,
+ const char *filename)
+{
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ struct mscabd_cabinet_p *cab = NULL;
+ struct mspack_system *sys;
+ unsigned char *search_buf;
+ struct mspack_file *fh;
+ off_t filelen, firstlen = 0;
+
+ if (!base) return NULL;
+ sys = self->system;
+
+ /* allocate a search buffer */
+ search_buf = (unsigned char *) sys->alloc(sys, (size_t) self->param[MSCABD_PARAM_SEARCHBUF]);
+ if (!search_buf) {
+ self->error = MSPACK_ERR_NOMEMORY;
+ return NULL;
+ }
+
+ /* open file and get its full file length */
+ if ((fh = sys->open(sys, filename, MSPACK_SYS_OPEN_READ))) {
+ if (!(self->error = mspack_sys_filelen(sys, fh, &filelen))) {
+ self->error = cabd_find(self, search_buf, fh, filename,
+ filelen, &firstlen, &cab);
+ }
+
+ /* truncated / extraneous data warning: */
+ if (firstlen && (firstlen != filelen) &&
+ (!cab || (cab->base.base_offset == 0)))
+ {
+ if (firstlen < filelen) {
+ sys->message(fh, "WARNING; possible %" LD
+ " extra bytes at end of file.",
+ filelen - firstlen);
+ }
+ else {
+ sys->message(fh, "WARNING; file possibly truncated by %" LD " bytes.",
+ firstlen - filelen);
+ }
+ }
+
+ sys->close(fh);
+ }
+ else {
+ self->error = MSPACK_ERR_OPEN;
+ }
+
+ /* free the search buffer */
+ sys->free(search_buf);
+
+ return (struct mscabd_cabinet *) cab;
+}
+
+static int cabd_find(struct mscab_decompressor_p *self, unsigned char *buf,
+ struct mspack_file *fh, const char *filename, off_t flen,
+ off_t *firstlen, struct mscabd_cabinet_p **firstcab)
+{
+ struct mscabd_cabinet_p *cab, *link = NULL;
+ off_t caboff, offset, length;
+ struct mspack_system *sys = self->system;
+ unsigned char *p, *pend, state = 0;
+ unsigned int cablen_u32 = 0, foffset_u32 = 0;
+ int false_cabs = 0;
+
+#ifndef LARGEFILE_SUPPORT
+ /* detect 32-bit off_t overflow */
+ if (flen < 0) {
+ sys->message(fh, largefile_msg);
+ return MSPACK_ERR_OK;
+ }
+#endif
+
+ /* search through the full file length */
+ for (offset = 0; offset < flen; offset += length) {
+ /* search length is either the full length of the search buffer, or the
+ * amount of data remaining to the end of the file, whichever is less. */
+ length = flen - offset;
+ if (length > self->param[MSCABD_PARAM_SEARCHBUF]) {
+ length = self->param[MSCABD_PARAM_SEARCHBUF];
+ }
+
+ /* fill the search buffer with data from disk */
+ if (sys->read(fh, &buf[0], (int) length) != (int) length) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* FAQ avoidance strategy */
+ if ((offset == 0) && (EndGetI32(&buf[0]) == 0x28635349)) {
+ sys->message(fh, "WARNING; found InstallShield header. "
+ "This is probably an InstallShield file. "
+ "Use UNSHIELD from www.synce.org to unpack it.");
+ }
+
+ /* read through the entire buffer. */
+ for (p = &buf[0], pend = &buf[length]; p < pend; ) {
+ switch (state) {
+ /* starting state */
+ case 0:
+ /* we spend most of our time in this while loop, looking for
+ * a leading 'M' of the 'MSCF' signature */
+ while (p < pend && *p != 0x4D) p++;
+ /* if we found tht 'M', advance state */
+ if (p++ < pend) state = 1;
+ break;
+
+ /* verify that the next 3 bytes are 'S', 'C' and 'F' */
+ case 1: state = (*p++ == 0x53) ? 2 : 0; break;
+ case 2: state = (*p++ == 0x43) ? 3 : 0; break;
+ case 3: state = (*p++ == 0x46) ? 4 : 0; break;
+
+ /* we don't care about bytes 4-7 (see default: for action) */
+
+ /* bytes 8-11 are the overall length of the cabinet */
+ case 8: cablen_u32 = *p++; state++; break;
+ case 9: cablen_u32 |= *p++ << 8; state++; break;
+ case 10: cablen_u32 |= *p++ << 16; state++; break;
+ case 11: cablen_u32 |= *p++ << 24; state++; break;
+
+ /* we don't care about bytes 12-15 (see default: for action) */
+
+ /* bytes 16-19 are the offset within the cabinet of the filedata */
+ case 16: foffset_u32 = *p++; state++; break;
+ case 17: foffset_u32 |= *p++ << 8; state++; break;
+ case 18: foffset_u32 |= *p++ << 16; state++; break;
+ case 19: foffset_u32 |= *p++ << 24;
+ /* now we have recieved 20 bytes of potential cab header. work out
+ * the offset in the file of this potential cabinet */
+ caboff = offset + (p - &buf[0]) - 20;
+
+ /* should reading cabinet fail, restart search just after 'MSCF' */
+ offset = caboff + 4;
+
+ /* capture the "length of cabinet" field if there is a cabinet at
+ * offset 0 in the file, regardless of whether the cabinet can be
+ * read correctly or not */
+ if (caboff == 0) *firstlen = (off_t) cablen_u32;
+
+ /* check that the files offset is less than the alleged length of
+ * the cabinet, and that the offset + the alleged length are
+ * 'roughly' within the end of overall file length */
+ if ((foffset_u32 < cablen_u32) &&
+ ((caboff + (off_t) foffset_u32) < (flen + 32)) &&
+ ((caboff + (off_t) cablen_u32) < (flen + 32)) )
+ {
+ /* likely cabinet found -- try reading it */
+ if (!(cab = (struct mscabd_cabinet_p *) sys->alloc(sys, sizeof(struct mscabd_cabinet_p)))) {
+ return MSPACK_ERR_NOMEMORY;
+ }
+ cab->base.filename = filename;
+ if (cabd_read_headers(sys, fh, cab, caboff, 1)) {
+ /* destroy the failed cabinet */
+ cabd_close((struct mscab_decompressor *) self,
+ (struct mscabd_cabinet *) cab);
+ false_cabs++;
+ }
+ else {
+ /* cabinet read correctly! */
+
+ /* link the cab into the list */
+ if (!link) *firstcab = cab;
+ else link->base.next = (struct mscabd_cabinet *) cab;
+ link = cab;
+
+ /* cause the search to restart after this cab's data. */
+ offset = caboff + (off_t) cablen_u32;
+
+#ifndef LARGEFILE_SUPPORT
+ /* detect 32-bit off_t overflow */
+ if (offset < caboff) {
+ sys->message(fh, largefile_msg);
+ return MSPACK_ERR_OK;
+ }
+#endif
+ }
+ }
+
+ /* restart search */
+ if (offset >= flen) return MSPACK_ERR_OK;
+ if (sys->seek(fh, offset, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+ length = 0;
+ p = pend;
+ state = 0;
+ break;
+
+ /* for bytes 4-7 and 12-15, just advance state/pointer */
+ default:
+ p++, state++;
+ } /* switch(state) */
+ } /* for (... p < pend ...) */
+ } /* for (... offset < length ...) */
+
+ if (false_cabs) {
+ D(("%d false cabinets found", false_cabs))
+ }
+
+ return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * CABD_MERGE, CABD_PREPEND, CABD_APPEND
+ ***************************************
+ * joins cabinets together, also merges split folders between these two
+ * cabinets only. This includes freeing the duplicate folder and file(s)
+ * and allocating a further mscabd_folder_data structure to append to the
+ * merged folder's data parts list.
+ */
+static int cabd_prepend(struct mscab_decompressor *base,
+ struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *prevcab)
+{
+ return cabd_merge(base, prevcab, cab);
+}
+
+static int cabd_append(struct mscab_decompressor *base,
+ struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *nextcab)
+{
+ return cabd_merge(base, cab, nextcab);
+}
+
+static int cabd_merge(struct mscab_decompressor *base,
+ struct mscabd_cabinet *lcab,
+ struct mscabd_cabinet *rcab)
+{
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ struct mscabd_folder_data *data, *ndata;
+ struct mscabd_folder_p *lfol, *rfol;
+ struct mscabd_file *fi, *rfi, *lfi;
+ struct mscabd_cabinet *cab;
+ struct mspack_system *sys;
+
+ if (!self) return MSPACK_ERR_ARGS;
+ sys = self->system;
+
+ /* basic args check */
+ if (!lcab || !rcab || (lcab == rcab)) {
+ D(("lcab NULL, rcab NULL or lcab = rcab"))
+ return self->error = MSPACK_ERR_ARGS;
+ }
+
+ /* check there's not already a cabinet attached */
+ if (lcab->nextcab || rcab->prevcab) {
+ D(("cabs already joined"))
+ return self->error = MSPACK_ERR_ARGS;
+ }
+
+ /* do not create circular cabinet chains */
+ for (cab = lcab->prevcab; cab; cab = cab->prevcab) {
+ if (cab == rcab) {D(("circular!")) return self->error = MSPACK_ERR_ARGS;}
+ }
+ for (cab = rcab->nextcab; cab; cab = cab->nextcab) {
+ if (cab == lcab) {D(("circular!")) return self->error = MSPACK_ERR_ARGS;}
+ }
+
+ /* warn about odd set IDs or indices */
+ if (lcab->set_id != rcab->set_id) {
+ sys->message(NULL, "WARNING; merged cabinets with differing Set IDs.");
+ }
+
+ if (lcab->set_index > rcab->set_index) {
+ sys->message(NULL, "WARNING; merged cabinets with odd order.");
+ }
+
+ /* merging the last folder in lcab with the first folder in rcab */
+ lfol = (struct mscabd_folder_p *) lcab->folders;
+ rfol = (struct mscabd_folder_p *) rcab->folders;
+ while (lfol->base.next) lfol = (struct mscabd_folder_p *) lfol->base.next;
+
+ /* do we need to merge folders? */
+ if (!lfol->merge_next && !rfol->merge_prev) {
+ /* no, at least one of the folders is not for merging */
+
+ /* attach cabs */
+ lcab->nextcab = rcab;
+ rcab->prevcab = lcab;
+
+ /* attach folders */
+ lfol->base.next = (struct mscabd_folder *) rfol;
+
+ /* attach files */
+ fi = lcab->files;
+ while (fi->next) fi = fi->next;
+ fi->next = rcab->files;
+ }
+ else {
+ /* folder merge required - do the files match? */
+ if (! cabd_can_merge_folders(sys, lfol, rfol)) {
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* allocate a new folder data structure */
+ if (!(data = (struct mscabd_folder_data *) sys->alloc(sys, sizeof(struct mscabd_folder_data)))) {
+ return self->error = MSPACK_ERR_NOMEMORY;
+ }
+
+ /* attach cabs */
+ lcab->nextcab = rcab;
+ rcab->prevcab = lcab;
+
+ /* append rfol's data to lfol */
+ ndata = &lfol->data;
+ while (ndata->next) ndata = ndata->next;
+ ndata->next = data;
+ *data = rfol->data;
+ rfol->data.next = NULL;
+
+ /* lfol becomes rfol.
+ * NOTE: special case, don't merge if rfol is merge prev and next,
+ * rfol->merge_next is going to be deleted, so keep lfol's version
+ * instead */
+ lfol->base.num_blocks += rfol->base.num_blocks - 1;
+ if ((rfol->merge_next == NULL) ||
+ (rfol->merge_next->folder != (struct mscabd_folder *) rfol))
+ {
+ lfol->merge_next = rfol->merge_next;
+ }
+
+ /* attach the rfol's folder (except the merge folder) */
+ while (lfol->base.next) lfol = (struct mscabd_folder_p *) lfol->base.next;
+ lfol->base.next = rfol->base.next;
+
+ /* free disused merge folder */
+ sys->free(rfol);
+
+ /* attach rfol's files */
+ fi = lcab->files;
+ while (fi->next) fi = fi->next;
+ fi->next = rcab->files;
+
+ /* delete all files from rfol's merge folder */
+ lfi = NULL;
+ for (fi = lcab->files; fi ; fi = rfi) {
+ rfi = fi->next;
+ /* if file's folder matches the merge folder, unlink and free it */
+ if (fi->folder == (struct mscabd_folder *) rfol) {
+ if (lfi) lfi->next = rfi; else lcab->files = rfi;
+ sys->free(fi->filename);
+ sys->free(fi);
+ }
+ else lfi = fi;
+ }
+ }
+
+ /* all done! fix files and folders pointers in all cabs so they all
+ * point to the same list */
+ for (cab = lcab->prevcab; cab; cab = cab->prevcab) {
+ cab->files = lcab->files;
+ cab->folders = lcab->folders;
+ }
+
+ for (cab = lcab->nextcab; cab; cab = cab->nextcab) {
+ cab->files = lcab->files;
+ cab->folders = lcab->folders;
+ }
+
+ return self->error = MSPACK_ERR_OK;
+}
+
+/* decides if two folders are OK to merge */
+static int cabd_can_merge_folders(struct mspack_system *sys,
+ struct mscabd_folder_p *lfol,
+ struct mscabd_folder_p *rfol)
+{
+ struct mscabd_file *lfi, *rfi, *l, *r;
+ int matching = 1;
+
+ /* check that both folders use the same compression method/settings */
+ if (lfol->base.comp_type != rfol->base.comp_type) {
+ D(("folder merge: compression type mismatch"))
+ return 0;
+ }
+
+ if (!(lfi = lfol->merge_next) || !(rfi = rfol->merge_prev)) {
+ D(("folder merge: one cabinet has no files to merge"))
+ return 0;
+ }
+
+ /* for all files in lfol (which is the last folder in whichever cab and
+ * only has files to merge), compare them to the files from rfol. They
+ * should be identical in number and order. to verify this, check the
+ * offset and length of each file. */
+ for (l=lfi, r=rfi; l; l=l->next, r=r->next) {
+ if (!r || (l->offset != r->offset) || (l->length != r->length)) {
+ matching = 0;
+ break;
+ }
+ }
+
+ if (matching) return 1;
+
+ /* if rfol does not begin with an identical copy of the files in lfol, make
+ * make a judgement call; if at least ONE file from lfol is in rfol, allow
+ * the merge with a warning about missing files. */
+ matching = 0;
+ for (l = lfi; l; l = l->next) {
+ for (r = rfi; r; r = r->next) {
+ if (l->offset == r->offset && l->length == r->length) break;
+ }
+ if (r) matching = 1; else sys->message(NULL,
+ "WARNING; merged file %s not listed in both cabinets", l->filename);
+ }
+ return matching;
+}
+
+
+/***************************************
+ * CABD_EXTRACT
+ ***************************************
+ * extracts a file from a cabinet
+ */
+static int cabd_extract(struct mscab_decompressor *base,
+ struct mscabd_file *file, const char *filename)
+{
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ struct mscabd_folder_p *fol;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+
+ if (!self) return MSPACK_ERR_ARGS;
+ if (!file) return self->error = MSPACK_ERR_ARGS;
+
+ sys = self->system;
+ fol = (struct mscabd_folder_p *) file->folder;
+
+ /* check if file can be extracted */
+ if ((!fol) || (fol->merge_prev) ||
+ (((file->offset + file->length) / CAB_BLOCKMAX) > fol->base.num_blocks))
+ {
+ sys->message(NULL, "ERROR; file \"%s\" cannot be extracted, "
+ "cabinet set is incomplete.", file->filename);
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* allocate generic decompression state */
+ if (!self->d) {
+ self->d = (struct mscabd_decompress_state *) sys->alloc(sys, sizeof(struct mscabd_decompress_state));
+ if (!self->d) return self->error = MSPACK_ERR_NOMEMORY;
+ self->d->folder = NULL;
+ self->d->data = NULL;
+ self->d->sys = *sys;
+ self->d->sys.read = &cabd_sys_read;
+ self->d->sys.write = &cabd_sys_write;
+ self->d->state = NULL;
+ self->d->infh = NULL;
+ self->d->incab = NULL;
+ }
+
+ /* do we need to change folder or reset the current folder? */
+ if ((self->d->folder != fol) || (self->d->offset > file->offset)) {
+ /* do we need to open a new cab file? */
+ if (!self->d->infh || (fol->data.cab != self->d->incab)) {
+ /* close previous file handle if from a different cab */
+ if (self->d->infh) sys->close(self->d->infh);
+ self->d->incab = fol->data.cab;
+ self->d->infh = sys->open(sys, fol->data.cab->base.filename,
+ MSPACK_SYS_OPEN_READ);
+ if (!self->d->infh) return self->error = MSPACK_ERR_OPEN;
+ }
+ /* seek to start of data blocks */
+ if (sys->seek(self->d->infh, fol->data.offset, MSPACK_SYS_SEEK_START)) {
+ return self->error = MSPACK_ERR_SEEK;
+ }
+
+ /* set up decompressor */
+ if (cabd_init_decomp(self, (unsigned int) fol->base.comp_type)) {
+ return self->error;
+ }
+
+ /* initialise new folder state */
+ self->d->folder = fol;
+ self->d->data = &fol->data;
+ self->d->offset = 0;
+ self->d->block = 0;
+ self->d->i_ptr = self->d->i_end = &self->d->input[0];
+
+ /* read_error lasts for the lifetime of a decompressor */
+ self->read_error = MSPACK_ERR_OK;
+ }
+
+ /* open file for output */
+ if (!(fh = sys->open(sys, filename, MSPACK_SYS_OPEN_WRITE))) {
+ return self->error = MSPACK_ERR_OPEN;
+ }
+
+ self->error = MSPACK_ERR_OK;
+
+ /* if file has more than 0 bytes */
+ if (file->length) {
+ off_t bytes;
+ int error;
+ /* get to correct offset.
+ * - use NULL fh to say 'no writing' to cabd_sys_write()
+ * - if cabd_sys_read() has an error, it will set self->read_error
+ * and pass back MSPACK_ERR_READ
+ */
+ self->d->outfh = NULL;
+ if ((bytes = file->offset - self->d->offset)) {
+ error = self->d->decompress(self->d->state, bytes);
+ self->error = (error == MSPACK_ERR_READ) ? self->read_error : error;
+ }
+
+ /* if getting to the correct offset was error free, unpack file */
+ if (!self->error) {
+ self->d->outfh = fh;
+ error = self->d->decompress(self->d->state, (off_t) file->length);
+ self->error = (error == MSPACK_ERR_READ) ? self->read_error : error;
+ }
+ }
+
+ /* close output file */
+ sys->close(fh);
+ self->d->outfh = NULL;
+
+ return self->error;
+}
+
+/***************************************
+ * CABD_INIT_DECOMP, CABD_FREE_DECOMP
+ ***************************************
+ * cabd_init_decomp initialises decompression state, according to which
+ * decompression method was used. relies on self->d->folder being the same
+ * as when initialised.
+ *
+ * cabd_free_decomp frees decompression state, according to which method
+ * was used.
+ */
+static int cabd_init_decomp(struct mscab_decompressor_p *self, unsigned int ct)
+{
+ struct mspack_file *fh = (struct mspack_file *) self;
+
+ assert(self && self->d);
+
+ /* free any existing decompressor */
+ cabd_free_decomp(self);
+
+ self->d->comp_type = ct;
+
+ switch (ct & cffoldCOMPTYPE_MASK) {
+ case cffoldCOMPTYPE_NONE:
+ self->d->decompress = (int (*)(void *, off_t)) &noned_decompress;
+ self->d->state = noned_init(&self->d->sys, fh, fh,
+ self->param[MSCABD_PARAM_DECOMPBUF]);
+ break;
+ case cffoldCOMPTYPE_MSZIP:
+ self->d->decompress = (int (*)(void *, off_t)) &mszipd_decompress;
+ self->d->state = mszipd_init(&self->d->sys, fh, fh,
+ self->param[MSCABD_PARAM_DECOMPBUF],
+ self->param[MSCABD_PARAM_FIXMSZIP]);
+ break;
+ case cffoldCOMPTYPE_QUANTUM:
+ self->d->decompress = (int (*)(void *, off_t)) &qtmd_decompress;
+ self->d->state = qtmd_init(&self->d->sys, fh, fh, (int) (ct >> 8) & 0x1f,
+ self->param[MSCABD_PARAM_DECOMPBUF]);
+ break;
+ case cffoldCOMPTYPE_LZX:
+ self->d->decompress = (int (*)(void *, off_t)) &lzxd_decompress;
+ self->d->state = lzxd_init(&self->d->sys, fh, fh, (int) (ct >> 8) & 0x1f, 0,
+ self->param[MSCABD_PARAM_DECOMPBUF], (off_t) 0);
+ break;
+ default:
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+ return self->error = (self->d->state) ? MSPACK_ERR_OK : MSPACK_ERR_NOMEMORY;
+}
+
+static void cabd_free_decomp(struct mscab_decompressor_p *self) {
+ if (!self || !self->d || !self->d->folder || !self->d->state) return;
+
+ switch (self->d->comp_type & cffoldCOMPTYPE_MASK) {
+ case cffoldCOMPTYPE_NONE: noned_free((struct noned_state *) self->d->state); break;
+ case cffoldCOMPTYPE_MSZIP: mszipd_free((struct mszipd_stream *) self->d->state); break;
+ case cffoldCOMPTYPE_QUANTUM: qtmd_free((struct qtmd_stream *) self->d->state); break;
+ case cffoldCOMPTYPE_LZX: lzxd_free((struct lzxd_stream *) self->d->state); break;
+ }
+ self->d->decompress = NULL;
+ self->d->state = NULL;
+}
+
+/***************************************
+ * CABD_SYS_READ, CABD_SYS_WRITE
+ ***************************************
+ * cabd_sys_read is the internal reader function which the decompressors
+ * use. will read data blocks (and merge split blocks) from the cabinet
+ * and serve the read bytes to the decompressors
+ *
+ * cabd_sys_write is the internal writer function which the decompressors
+ * use. it either writes data to disk (self->d->outfh) with the real
+ * sys->write() function, or does nothing with the data when
+ * self->d->outfh == NULL. advances self->d->offset
+ */
+static int cabd_sys_read(struct mspack_file *file, void *buffer, int bytes) {
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) file;
+ unsigned char *buf = (unsigned char *) buffer;
+ struct mspack_system *sys = self->system;
+ int avail, todo, outlen, ignore_cksum;
+
+ ignore_cksum = self->param[MSCABD_PARAM_FIXMSZIP] &&
+ ((self->d->comp_type & cffoldCOMPTYPE_MASK) == cffoldCOMPTYPE_MSZIP);
+
+ todo = bytes;
+ while (todo > 0) {
+ avail = self->d->i_end - self->d->i_ptr;
+
+ /* if out of input data, read a new block */
+ if (avail) {
+ /* copy as many input bytes available as possible */
+ if (avail > todo) avail = todo;
+ sys->copy(self->d->i_ptr, buf, (size_t) avail);
+ self->d->i_ptr += avail;
+ buf += avail;
+ todo -= avail;
+ }
+ else {
+ /* out of data, read a new block */
+
+ /* check if we're out of input blocks, advance block counter */
+ if (self->d->block++ >= self->d->folder->base.num_blocks) {
+ self->read_error = MSPACK_ERR_DATAFORMAT;
+ break;
+ }
+
+ /* read a block */
+ self->read_error = cabd_sys_read_block(sys, self->d, &outlen, ignore_cksum);
+ if (self->read_error) return -1;
+
+ /* special Quantum hack -- trailer byte to allow the decompressor
+ * to realign itself. CAB Quantum blocks, unlike LZX blocks, can have
+ * anything from 0 to 4 trailing null bytes. */
+ if ((self->d->comp_type & cffoldCOMPTYPE_MASK)==cffoldCOMPTYPE_QUANTUM) {
+ *self->d->i_end++ = 0xFF;
+ }
+
+ /* is this the last block? */
+ if (self->d->block >= self->d->folder->base.num_blocks) {
+ /* last block */
+ if ((self->d->comp_type & cffoldCOMPTYPE_MASK) == cffoldCOMPTYPE_LZX) {
+ /* special LZX hack -- on the last block, inform LZX of the
+ * size of the output data stream. */
+ lzxd_set_output_length((struct lzxd_stream *) self->d->state, (off_t)
+ ((self->d->block-1) * CAB_BLOCKMAX + outlen));
+ }
+ }
+ else {
+ /* not the last block */
+ if (outlen != CAB_BLOCKMAX) {
+ self->system->message(self->d->infh,
+ "WARNING; non-maximal data block");
+ }
+ }
+ } /* if (avail) */
+ } /* while (todo > 0) */
+ return bytes - todo;
+}
+
+static int cabd_sys_write(struct mspack_file *file, void *buffer, int bytes) {
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) file;
+ self->d->offset += bytes;
+ if (self->d->outfh) {
+ return self->system->write(self->d->outfh, buffer, bytes);
+ }
+ return bytes;
+}
+
+/***************************************
+ * CABD_SYS_READ_BLOCK
+ ***************************************
+ * reads a whole data block from a cab file. the block may span more than
+ * one cab file, if it does then the fragments will be reassembled
+ */
+static int cabd_sys_read_block(struct mspack_system *sys,
+ struct mscabd_decompress_state *d,
+ int *out, int ignore_cksum)
+{
+ unsigned char hdr[cfdata_SIZEOF];
+ unsigned int cksum;
+ int len;
+
+ /* reset the input block pointer and end of block pointer */
+ d->i_ptr = d->i_end = &d->input[0];
+
+ do {
+ /* read the block header */
+ if (sys->read(d->infh, &hdr[0], cfdata_SIZEOF) != cfdata_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* skip any reserved block headers */
+ if (d->data->cab->block_resv &&
+ sys->seek(d->infh, (off_t) d->data->cab->block_resv,
+ MSPACK_SYS_SEEK_CUR))
+ {
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* blocks must not be over CAB_INPUTMAX in size */
+ len = EndGetI16(&hdr[cfdata_CompressedSize]);
+ if (((d->i_end - d->i_ptr) + len) > CAB_INPUTMAX) {
+ D(("block size > CAB_INPUTMAX (%ld + %d)", d->i_end - d->i_ptr, len))
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* blocks must not expand to more than CAB_BLOCKMAX */
+ if (EndGetI16(&hdr[cfdata_UncompressedSize]) > CAB_BLOCKMAX) {
+ D(("block size > CAB_BLOCKMAX"))
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* read the block data */
+ if (sys->read(d->infh, d->i_end, len) != len) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* perform checksum test on the block (if one is stored) */
+ if ((cksum = EndGetI32(&hdr[cfdata_CheckSum]))) {
+ unsigned int sum2 = cabd_checksum(d->i_end, (unsigned int) len, 0);
+ if (cabd_checksum(&hdr[4], 4, sum2) != cksum) {
+ if (!ignore_cksum) return MSPACK_ERR_CHECKSUM;
+ sys->message(d->infh, "WARNING; bad block checksum found");
+ }
+ }
+
+ /* advance end of block pointer to include newly read data */
+ d->i_end += len;
+
+ /* uncompressed size == 0 means this block was part of a split block
+ * and it continues as the first block of the next cabinet in the set.
+ * otherwise, this is the last part of the block, and no more block
+ * reading needs to be done.
+ */
+ /* EXIT POINT OF LOOP -- uncompressed size != 0 */
+ if ((*out = EndGetI16(&hdr[cfdata_UncompressedSize]))) {
+ return MSPACK_ERR_OK;
+ }
+
+ /* otherwise, advance to next cabinet */
+
+ /* close current file handle */
+ sys->close(d->infh);
+ d->infh = NULL;
+
+ /* advance to next member in the cabinet set */
+ if (!(d->data = d->data->next)) {
+ D(("ran out of splits in cabinet set"))
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* open next cab file */
+ d->incab = d->data->cab;
+ if (!(d->infh = sys->open(sys, d->incab->base.filename,
+ MSPACK_SYS_OPEN_READ)))
+ {
+ return MSPACK_ERR_OPEN;
+ }
+
+ /* seek to start of data blocks */
+ if (sys->seek(d->infh, d->data->offset, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+ } while (1);
+
+ /* not reached */
+ return MSPACK_ERR_OK;
+}
+
+static unsigned int cabd_checksum(unsigned char *data, unsigned int bytes,
+ unsigned int cksum)
+{
+ unsigned int len, ul = 0;
+
+ for (len = bytes >> 2; len--; data += 4) {
+ cksum ^= ((data[0]) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24));
+ }
+
+ switch (bytes & 3) {
+ case 3: ul |= *data++ << 16;
+ case 2: ul |= *data++ << 8;
+ case 1: ul |= *data;
+ }
+ cksum ^= ul;
+
+ return cksum;
+}
+
+/***************************************
+ * NONED_INIT, NONED_DECOMPRESS, NONED_FREE
+ ***************************************
+ * the "not compressed" method decompressor
+ */
+struct noned_state {
+ struct mspack_system *sys;
+ struct mspack_file *i;
+ struct mspack_file *o;
+ unsigned char *buf;
+ int bufsize;
+};
+
+static struct noned_state *noned_init(struct mspack_system *sys,
+ struct mspack_file *in,
+ struct mspack_file *out,
+ int bufsize)
+{
+ struct noned_state *state = (struct noned_state *) sys->alloc(sys, sizeof(struct noned_state));
+ unsigned char *buf = (unsigned char *) sys->alloc(sys, (size_t) bufsize);
+ if (state && buf) {
+ state->sys = sys;
+ state->i = in;
+ state->o = out;
+ state->buf = buf;
+ state->bufsize = bufsize;
+ }
+ else {
+ sys->free(buf);
+ sys->free(state);
+ state = NULL;
+ }
+ return state;
+}
+
+static int noned_decompress(struct noned_state *s, off_t bytes) {
+ int run;
+ while (bytes > 0) {
+ run = (bytes > s->bufsize) ? s->bufsize : (int) bytes;
+ if (s->sys->read(s->i, &s->buf[0], run) != run) return MSPACK_ERR_READ;
+ if (s->sys->write(s->o, &s->buf[0], run) != run) return MSPACK_ERR_WRITE;
+ bytes -= run;
+ }
+ return MSPACK_ERR_OK;
+}
+
+static void noned_free(struct noned_state *state) {
+ struct mspack_system *sys;
+ if (state) {
+ sys = state->sys;
+ sys->free(state->buf);
+ sys->free(state);
+ }
+}
+
+
+/***************************************
+ * CABD_PARAM
+ ***************************************
+ * allows a parameter to be set
+ */
+static int cabd_param(struct mscab_decompressor *base, int param, int value) {
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ if (!self) return MSPACK_ERR_ARGS;
+
+ switch (param) {
+ case MSCABD_PARAM_SEARCHBUF:
+ if (value < 4) return MSPACK_ERR_ARGS;
+ self->param[MSCABD_PARAM_SEARCHBUF] = value;
+ break;
+ case MSCABD_PARAM_FIXMSZIP:
+ self->param[MSCABD_PARAM_FIXMSZIP] = value;
+ break;
+ case MSCABD_PARAM_DECOMPBUF:
+ if (value < 4) return MSPACK_ERR_ARGS;
+ self->param[MSCABD_PARAM_DECOMPBUF] = value;
+ break;
+ default:
+ return MSPACK_ERR_ARGS;
+ }
+ return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * CABD_ERROR
+ ***************************************
+ * returns the last error that occurred
+ */
+static int cabd_error(struct mscab_decompressor *base) {
+ struct mscab_decompressor_p *self = (struct mscab_decompressor_p *) base;
+ return (self) ? self->error : MSPACK_ERR_ARGS;
+}
diff --git a/rbutil/rbutilqt/mspack/chm.h b/rbutil/rbutilqt/mspack/chm.h
new file mode 100644
index 0000000000..a85d2e1731
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/chm.h
@@ -0,0 +1,122 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_CHM_H
+#define MSPACK_CHM_H 1
+
+#include <lzx.h>
+
+/* generic CHM definitions */
+
+#define chmhead_Signature (0x0000)
+#define chmhead_Version (0x0004)
+#define chmhead_HeaderLen (0x0008)
+#define chmhead_Unknown1 (0x000C)
+#define chmhead_Timestamp (0x0010)
+#define chmhead_LanguageID (0x0014)
+#define chmhead_GUID1 (0x0018)
+#define chmhead_GUID2 (0x0028)
+#define chmhead_SIZEOF (0x0038)
+
+#define chmhst_OffsetHS0 (0x0000)
+#define chmhst_LengthHS0 (0x0008)
+#define chmhst_OffsetHS1 (0x0010)
+#define chmhst_LengthHS1 (0x0018)
+#define chmhst_SIZEOF (0x0020)
+#define chmhst3_OffsetCS0 (0x0020)
+#define chmhst3_SIZEOF (0x0028)
+
+#define chmhs0_Unknown1 (0x0000)
+#define chmhs0_Unknown2 (0x0004)
+#define chmhs0_FileLen (0x0008)
+#define chmhs0_Unknown3 (0x0010)
+#define chmhs0_Unknown4 (0x0014)
+#define chmhs0_SIZEOF (0x0018)
+
+#define chmhs1_Signature (0x0000)
+#define chmhs1_Version (0x0004)
+#define chmhs1_HeaderLen (0x0008)
+#define chmhs1_Unknown1 (0x000C)
+#define chmhs1_ChunkSize (0x0010)
+#define chmhs1_Density (0x0014)
+#define chmhs1_Depth (0x0018)
+#define chmhs1_IndexRoot (0x001C)
+#define chmhs1_FirstPMGL (0x0020)
+#define chmhs1_LastPMGL (0x0024)
+#define chmhs1_Unknown2 (0x0028)
+#define chmhs1_NumChunks (0x002C)
+#define chmhs1_LanguageID (0x0030)
+#define chmhs1_GUID (0x0034)
+#define chmhs1_Unknown3 (0x0044)
+#define chmhs1_Unknown4 (0x0048)
+#define chmhs1_Unknown5 (0x004C)
+#define chmhs1_Unknown6 (0x0050)
+#define chmhs1_SIZEOF (0x0054)
+
+#define pmgl_Signature (0x0000)
+#define pmgl_QuickRefSize (0x0004)
+#define pmgl_Unknown1 (0x0008)
+#define pmgl_PrevChunk (0x000C)
+#define pmgl_NextChunk (0x0010)
+#define pmgl_Entries (0x0014)
+#define pmgl_headerSIZEOF (0x0014)
+
+#define pmgi_Signature (0x0000)
+#define pmgi_QuickRefSize (0x0004)
+#define pmgi_Entries (0x0008)
+#define pmgi_headerSIZEOF (0x000C)
+
+#define lzxcd_Length (0x0000)
+#define lzxcd_Signature (0x0004)
+#define lzxcd_Version (0x0008)
+#define lzxcd_ResetInterval (0x000C)
+#define lzxcd_WindowSize (0x0010)
+#define lzxcd_CacheSize (0x0014)
+#define lzxcd_Unknown1 (0x0018)
+#define lzxcd_SIZEOF (0x001C)
+
+#define lzxrt_Unknown1 (0x0000)
+#define lzxrt_NumEntries (0x0004)
+#define lzxrt_EntrySize (0x0008)
+#define lzxrt_TableOffset (0x000C)
+#define lzxrt_UncompLen (0x0010)
+#define lzxrt_CompLen (0x0018)
+#define lzxrt_FrameLen (0x0020)
+#define lzxrt_Entries (0x0028)
+#define lzxrt_headerSIZEOF (0x0028)
+
+/* CHM compression definitions */
+
+struct mschm_compressor_p {
+ struct mschm_compressor base;
+ struct mspack_system *system;
+ char *temp_file;
+ int use_temp_file;
+ int error;
+};
+
+/* CHM decompression definitions */
+struct mschmd_decompress_state {
+ struct mschmd_header *chm; /* CHM file being decompressed */
+ off_t offset; /* uncompressed offset within folder */
+ off_t inoffset; /* offset in input file */
+ struct lzxd_stream *state; /* LZX decompressor state */
+ struct mspack_system sys; /* special I/O code for decompressor */
+ struct mspack_file *infh; /* input file handle */
+ struct mspack_file *outfh; /* output file handle */
+};
+
+struct mschm_decompressor_p {
+ struct mschm_decompressor base;
+ struct mspack_system *system;
+ struct mschmd_decompress_state *d;
+ int error;
+};
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/chmc.c b/rbutil/rbutilqt/mspack/chmc.c
new file mode 100644
index 0000000000..72f6c5b389
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/chmc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* CHM compression implementation */
+
+#include <system.h>
+#include <chm.h>
+
+struct mschm_compressor *
+ mspack_create_chm_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_chm_compressor(struct mschm_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/chmd.c b/rbutil/rbutilqt/mspack/chmd.c
new file mode 100644
index 0000000000..6e4a1bf24f
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/chmd.c
@@ -0,0 +1,1346 @@
+/* This file is part of libmspack.
+ * (C) 2003-2011 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* CHM decompression implementation */
+
+#include <system.h>
+#include <chm.h>
+
+/* prototypes */
+static struct mschmd_header * chmd_open(
+ struct mschm_decompressor *base, const char *filename);
+static struct mschmd_header * chmd_fast_open(
+ struct mschm_decompressor *base, const char *filename);
+static struct mschmd_header *chmd_real_open(
+ struct mschm_decompressor *base, const char *filename, int entire);
+static void chmd_close(
+ struct mschm_decompressor *base, struct mschmd_header *chm);
+static int chmd_read_headers(
+ struct mspack_system *sys, struct mspack_file *fh,
+ struct mschmd_header *chm, int entire);
+static int chmd_fast_find(
+ struct mschm_decompressor *base, struct mschmd_header *chm,
+ const char *filename, struct mschmd_file *f_ptr, int f_size);
+static unsigned char *read_chunk(
+ struct mschm_decompressor_p *self, struct mschmd_header *chm,
+ struct mspack_file *fh, unsigned int chunk);
+static int search_chunk(
+ struct mschmd_header *chm, const unsigned char *chunk, const char *filename,
+ const unsigned char **result, const unsigned char **result_end);
+static inline int compare(
+ const char *s1, const char *s2, int l1, int l2);
+static int chmd_extract(
+ struct mschm_decompressor *base, struct mschmd_file *file,
+ const char *filename);
+static int chmd_sys_write(
+ struct mspack_file *file, void *buffer, int bytes);
+static int chmd_init_decomp(
+ struct mschm_decompressor_p *self, struct mschmd_file *file);
+static int read_reset_table(
+ struct mschm_decompressor_p *self, struct mschmd_sec_mscompressed *sec,
+ int entry, off_t *length_ptr, off_t *offset_ptr);
+static int read_spaninfo(
+ struct mschm_decompressor_p *self, struct mschmd_sec_mscompressed *sec,
+ off_t *length_ptr);
+static int find_sys_file(
+ struct mschm_decompressor_p *self, struct mschmd_sec_mscompressed *sec,
+ struct mschmd_file **f_ptr, const char *name);
+static unsigned char *read_sys_file(
+ struct mschm_decompressor_p *self, struct mschmd_file *file);
+static int chmd_error(
+ struct mschm_decompressor *base);
+static int read_off64(
+ off_t *var, unsigned char *mem, struct mspack_system *sys,
+ struct mspack_file *fh);
+
+/* filenames of the system files used for decompression.
+ * Content and ControlData are essential.
+ * ResetTable is preferred, but SpanInfo can be used if not available
+ */
+static const char *content_name = "::DataSpace/Storage/MSCompressed/Content";
+static const char *control_name = "::DataSpace/Storage/MSCompressed/ControlData";
+static const char *spaninfo_name = "::DataSpace/Storage/MSCompressed/SpanInfo";
+static const char *rtable_name = "::DataSpace/Storage/MSCompressed/Transform/"
+ "{7FC28940-9D31-11D0-9B27-00A0C91E9C7C}/InstanceData/ResetTable";
+
+/***************************************
+ * MSPACK_CREATE_CHM_DECOMPRESSOR
+ ***************************************
+ * constructor
+ */
+struct mschm_decompressor *
+ mspack_create_chm_decompressor(struct mspack_system *sys)
+{
+ struct mschm_decompressor_p *self = NULL;
+
+ if (!sys) sys = mspack_default_system;
+ if (!mspack_valid_system(sys)) return NULL;
+
+ if ((self = (struct mschm_decompressor_p *) sys->alloc(sys, sizeof(struct mschm_decompressor_p)))) {
+ self->base.open = &chmd_open;
+ self->base.close = &chmd_close;
+ self->base.extract = &chmd_extract;
+ self->base.last_error = &chmd_error;
+ self->base.fast_open = &chmd_fast_open;
+ self->base.fast_find = &chmd_fast_find;
+ self->system = sys;
+ self->error = MSPACK_ERR_OK;
+ self->d = NULL;
+ }
+ return (struct mschm_decompressor *) self;
+}
+
+/***************************************
+ * MSPACK_DESTROY_CAB_DECOMPRESSOR
+ ***************************************
+ * destructor
+ */
+void mspack_destroy_chm_decompressor(struct mschm_decompressor *base) {
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ if (self) {
+ struct mspack_system *sys = self->system;
+ if (self->d) {
+ if (self->d->infh) sys->close(self->d->infh);
+ if (self->d->state) lzxd_free(self->d->state);
+ sys->free(self->d);
+ }
+ sys->free(self);
+ }
+}
+
+/***************************************
+ * CHMD_OPEN
+ ***************************************
+ * opens a file and tries to read it as a CHM file.
+ * Calls chmd_real_open() with entire=1.
+ */
+static struct mschmd_header *chmd_open(struct mschm_decompressor *base,
+ const char *filename)
+{
+ return chmd_real_open(base, filename, 1);
+}
+
+/***************************************
+ * CHMD_FAST_OPEN
+ ***************************************
+ * opens a file and tries to read it as a CHM file, but does not read
+ * the file headers. Calls chmd_real_open() with entire=0
+ */
+static struct mschmd_header *chmd_fast_open(struct mschm_decompressor *base,
+ const char *filename)
+{
+ return chmd_real_open(base, filename, 0);
+}
+
+/***************************************
+ * CHMD_REAL_OPEN
+ ***************************************
+ * the real implementation of chmd_open() and chmd_fast_open(). It simply
+ * passes the "entire" parameter to chmd_read_headers(), which will then
+ * either read all headers, or a bare mininum.
+ */
+static struct mschmd_header *chmd_real_open(struct mschm_decompressor *base,
+ const char *filename, int entire)
+{
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ struct mschmd_header *chm = NULL;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+ int error;
+
+ if (!base) return NULL;
+ sys = self->system;
+
+ if ((fh = sys->open(sys, filename, MSPACK_SYS_OPEN_READ))) {
+ if ((chm = (struct mschmd_header *) sys->alloc(sys, sizeof(struct mschmd_header)))) {
+ chm->filename = filename;
+ error = chmd_read_headers(sys, fh, chm, entire);
+ if (error) {
+ /* if the error is DATAFORMAT, and there are some results, return
+ * partial results with a warning, rather than nothing */
+ if (error == MSPACK_ERR_DATAFORMAT && (chm->files || chm->sysfiles)) {
+ sys->message(fh, "WARNING; contents are corrupt");
+ error = MSPACK_ERR_OK;
+ }
+ else {
+ chmd_close(base, chm);
+ chm = NULL;
+ }
+ }
+ self->error = error;
+ }
+ else {
+ self->error = MSPACK_ERR_NOMEMORY;
+ }
+ sys->close(fh);
+ }
+ else {
+ self->error = MSPACK_ERR_OPEN;
+ }
+ return chm;
+}
+
+/***************************************
+ * CHMD_CLOSE
+ ***************************************
+ * frees all memory associated with a given mschmd_header
+ */
+static void chmd_close(struct mschm_decompressor *base,
+ struct mschmd_header *chm)
+{
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ struct mschmd_file *fi, *nfi;
+ struct mspack_system *sys;
+ unsigned int i;
+
+ if (!base) return;
+ sys = self->system;
+
+ self->error = MSPACK_ERR_OK;
+
+ /* free files */
+ for (fi = chm->files; fi; fi = nfi) {
+ nfi = fi->next;
+ sys->free(fi);
+ }
+ for (fi = chm->sysfiles; fi; fi = nfi) {
+ nfi = fi->next;
+ sys->free(fi);
+ }
+
+ /* if this CHM was being decompressed, free decompression state */
+ if (self->d && (self->d->chm == chm)) {
+ if (self->d->infh) sys->close(self->d->infh);
+ if (self->d->state) lzxd_free(self->d->state);
+ sys->free(self->d);
+ self->d = NULL;
+ }
+
+ /* if this CHM had a chunk cache, free it and contents */
+ if (chm->chunk_cache) {
+ for (i = 0; i < chm->num_chunks; i++) sys->free(chm->chunk_cache[i]);
+ sys->free(chm->chunk_cache);
+ }
+
+ sys->free(chm);
+}
+
+/***************************************
+ * CHMD_READ_HEADERS
+ ***************************************
+ * reads the basic CHM file headers. If the "entire" parameter is
+ * non-zero, all file entries will also be read. fills out a pre-existing
+ * mschmd_header structure, allocates memory for files as necessary
+ */
+
+/* The GUIDs found in CHM headers */
+static const unsigned char guids[32] = {
+ /* {7C01FD10-7BAA-11D0-9E0C-00A0-C922-E6EC} */
+ 0x10, 0xFD, 0x01, 0x7C, 0xAA, 0x7B, 0xD0, 0x11,
+ 0x9E, 0x0C, 0x00, 0xA0, 0xC9, 0x22, 0xE6, 0xEC,
+ /* {7C01FD11-7BAA-11D0-9E0C-00A0-C922-E6EC} */
+ 0x11, 0xFD, 0x01, 0x7C, 0xAA, 0x7B, 0xD0, 0x11,
+ 0x9E, 0x0C, 0x00, 0xA0, 0xC9, 0x22, 0xE6, 0xEC
+};
+
+/* reads an encoded integer into a variable; 7 bits of data per byte,
+ * the high bit is used to indicate that there is another byte */
+#define READ_ENCINT(var) do { \
+ (var) = 0; \
+ do { \
+ if (p > end) goto chunk_end; \
+ (var) = ((var) << 7) | (*p & 0x7F); \
+ } while (*p++ & 0x80); \
+} while (0)
+
+static int chmd_read_headers(struct mspack_system *sys, struct mspack_file *fh,
+ struct mschmd_header *chm, int entire)
+{
+ unsigned int section, name_len, x, errors, num_chunks;
+ unsigned char buf[0x54], *chunk = NULL, *name, *p, *end;
+ struct mschmd_file *fi, *link = NULL;
+ off_t offset, length;
+ int num_entries;
+
+ /* initialise pointers */
+ chm->files = NULL;
+ chm->sysfiles = NULL;
+ chm->chunk_cache = NULL;
+ chm->sec0.base.chm = chm;
+ chm->sec0.base.id = 0;
+ chm->sec1.base.chm = chm;
+ chm->sec1.base.id = 1;
+ chm->sec1.content = NULL;
+ chm->sec1.control = NULL;
+ chm->sec1.spaninfo = NULL;
+ chm->sec1.rtable = NULL;
+
+ /* read the first header */
+ if (sys->read(fh, &buf[0], chmhead_SIZEOF) != chmhead_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* check ITSF signature */
+ if (EndGetI32(&buf[chmhead_Signature]) != 0x46535449) {
+ return MSPACK_ERR_SIGNATURE;
+ }
+
+ /* check both header GUIDs */
+ if (mspack_memcmp(&buf[chmhead_GUID1], &guids[0], 32L) != 0) {
+ D(("incorrect GUIDs"))
+ return MSPACK_ERR_SIGNATURE;
+ }
+
+ chm->version = EndGetI32(&buf[chmhead_Version]);
+ chm->timestamp = EndGetM32(&buf[chmhead_Timestamp]);
+ chm->language = EndGetI32(&buf[chmhead_LanguageID]);
+ if (chm->version > 3) {
+ sys->message(fh, "WARNING; CHM version > 3");
+ }
+
+ /* read the header section table */
+ if (sys->read(fh, &buf[0], chmhst3_SIZEOF) != chmhst3_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* chmhst3_OffsetCS0 does not exist in version 1 or 2 CHM files.
+ * The offset will be corrected later, once HS1 is read.
+ */
+ if (read_off64(&offset, &buf[chmhst_OffsetHS0], sys, fh) ||
+ read_off64(&chm->dir_offset, &buf[chmhst_OffsetHS1], sys, fh) ||
+ read_off64(&chm->sec0.offset, &buf[chmhst3_OffsetCS0], sys, fh))
+ {
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* seek to header section 0 */
+ if (sys->seek(fh, offset, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* read header section 0 */
+ if (sys->read(fh, &buf[0], chmhs0_SIZEOF) != chmhs0_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+ if (read_off64(&chm->length, &buf[chmhs0_FileLen], sys, fh)) {
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* seek to header section 1 */
+ if (sys->seek(fh, chm->dir_offset, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* read header section 1 */
+ if (sys->read(fh, &buf[0], chmhs1_SIZEOF) != chmhs1_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ chm->dir_offset = sys->tell(fh);
+ chm->chunk_size = EndGetI32(&buf[chmhs1_ChunkSize]);
+ chm->density = EndGetI32(&buf[chmhs1_Density]);
+ chm->depth = EndGetI32(&buf[chmhs1_Depth]);
+ chm->index_root = EndGetI32(&buf[chmhs1_IndexRoot]);
+ chm->num_chunks = EndGetI32(&buf[chmhs1_NumChunks]);
+ chm->first_pmgl = EndGetI32(&buf[chmhs1_FirstPMGL]);
+ chm->last_pmgl = EndGetI32(&buf[chmhs1_LastPMGL]);
+
+ if (chm->version < 3) {
+ /* versions before 3 don't have chmhst3_OffsetCS0 */
+ chm->sec0.offset = chm->dir_offset + (chm->chunk_size * chm->num_chunks);
+ }
+
+ /* ensure chunk size is large enough for signature and num_entries */
+ if (chm->chunk_size < (pmgl_Entries + 2)) {
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* if we are doing a quick read, stop here! */
+ if (!entire) {
+ return MSPACK_ERR_OK;
+ }
+
+ /* seek to the first PMGL chunk, and reduce the number of chunks to read */
+ if ((x = chm->first_pmgl) != 0) {
+ if (sys->seek(fh,(off_t) (x * chm->chunk_size), MSPACK_SYS_SEEK_CUR)) {
+ return MSPACK_ERR_SEEK;
+ }
+ }
+ num_chunks = chm->last_pmgl - x + 1;
+
+ if (!(chunk = (unsigned char *) sys->alloc(sys, (size_t)chm->chunk_size))) {
+ return MSPACK_ERR_NOMEMORY;
+ }
+
+ /* read and process all chunks from FirstPMGL to LastPMGL */
+ errors = 0;
+ while (num_chunks--) {
+ /* read next chunk */
+ if (sys->read(fh, chunk, (int)chm->chunk_size) != (int)chm->chunk_size) {
+ sys->free(chunk);
+ return MSPACK_ERR_READ;
+ }
+
+ /* process only directory (PMGL) chunks */
+ if (EndGetI32(&chunk[pmgl_Signature]) != 0x4C474D50) continue;
+
+ if (EndGetI32(&chunk[pmgl_QuickRefSize]) < 2) {
+ sys->message(fh, "WARNING; PMGL quickref area is too small");
+ }
+ if (EndGetI32(&chunk[pmgl_QuickRefSize]) >
+ ((int)chm->chunk_size - pmgl_Entries))
+ {
+ sys->message(fh, "WARNING; PMGL quickref area is too large");
+ }
+
+ p = &chunk[pmgl_Entries];
+ end = &chunk[chm->chunk_size - 2];
+ num_entries = EndGetI16(end);
+
+ while (num_entries--) {
+ READ_ENCINT(name_len); name = p; p += name_len;
+ READ_ENCINT(section);
+ READ_ENCINT(offset);
+ READ_ENCINT(length);
+
+ /* empty files and directory names are stored as a file entry at
+ * offset 0 with length 0. We want to keep empty files, but not
+ * directory names, which end with a "/" */
+ if ((offset == 0) && (length == 0)) {
+ if ((name_len > 0) && (name[name_len-1] == '/')) continue;
+ }
+
+ if (section > 1) {
+ sys->message(fh, "invalid section number '%u'.", section);
+ continue;
+ }
+
+ if (!(fi = (struct mschmd_file *) sys->alloc(sys, sizeof(struct mschmd_file) + name_len + 1))) {
+ sys->free(chunk);
+ return MSPACK_ERR_NOMEMORY;
+ }
+
+ fi->next = NULL;
+ fi->filename = (char *) &fi[1];
+ fi->section = ((section == 0) ? (struct mschmd_section *) (&chm->sec0)
+ : (struct mschmd_section *) (&chm->sec1));
+ fi->offset = offset;
+ fi->length = length;
+ sys->copy(name, fi->filename, (size_t) name_len);
+ fi->filename[name_len] = '\0';
+
+ if (name[0] == ':' && name[1] == ':') {
+ /* system file */
+ if (mspack_memcmp(&name[2], &content_name[2], 31L) == 0) {
+ if (mspack_memcmp(&name[33], &content_name[33], 8L) == 0) {
+ chm->sec1.content = fi;
+ }
+ else if (mspack_memcmp(&name[33], &control_name[33], 11L) == 0) {
+ chm->sec1.control = fi;
+ }
+ else if (mspack_memcmp(&name[33], &spaninfo_name[33], 8L) == 0) {
+ chm->sec1.spaninfo = fi;
+ }
+ else if (mspack_memcmp(&name[33], &rtable_name[33], 72L) == 0) {
+ chm->sec1.rtable = fi;
+ }
+ }
+ fi->next = chm->sysfiles;
+ chm->sysfiles = fi;
+ }
+ else {
+ /* normal file */
+ if (link) link->next = fi; else chm->files = fi;
+ link = fi;
+ }
+ }
+
+ /* this is reached either when num_entries runs out, or if
+ * reading data from the chunk reached a premature end of chunk */
+ chunk_end:
+ if (num_entries >= 0) {
+ D(("chunk ended before all entries could be read"))
+ errors++;
+ }
+
+ }
+ sys->free(chunk);
+ return (errors > 0) ? MSPACK_ERR_DATAFORMAT : MSPACK_ERR_OK;
+}
+
+/***************************************
+ * CHMD_FAST_FIND
+ ***************************************
+ * uses PMGI index chunks and quickref data to quickly locate a file
+ * directly from the on-disk index.
+ *
+ * TODO: protect against infinite loops in chunks (where pgml_NextChunk
+ * or a PGMI index entry point to an already visited chunk)
+ */
+static int chmd_fast_find(struct mschm_decompressor *base,
+ struct mschmd_header *chm, const char *filename,
+ struct mschmd_file *f_ptr, int f_size)
+{
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+ const unsigned char *chunk, *p, *end;
+ int err = MSPACK_ERR_OK, result = -1;
+ unsigned int n, sec;
+
+ if (!self || !chm || !f_ptr || (f_size != sizeof(struct mschmd_file))) {
+ return MSPACK_ERR_ARGS;
+ }
+ sys = self->system;
+
+ /* clear the results structure */
+ memset(f_ptr, 0, f_size);
+
+ if (!(fh = sys->open(sys, chm->filename, MSPACK_SYS_OPEN_READ))) {
+ return MSPACK_ERR_OPEN;
+ }
+
+ /* go through PMGI chunk hierarchy to reach PMGL chunk */
+ if (chm->index_root < chm->num_chunks) {
+ n = chm->index_root;
+ for (;;) {
+ if (!(chunk = read_chunk(self, chm, fh, n))) {
+ sys->close(fh);
+ return self->error;
+ }
+
+ /* search PMGI/PMGL chunk. exit early if no entry found */
+ if ((result = search_chunk(chm, chunk, filename, &p, &end)) <= 0) {
+ break;
+ }
+
+ /* found result. loop around for next chunk if this is PMGI */
+ if (chunk[3] == 0x4C) break; else READ_ENCINT(n);
+ }
+ }
+ else {
+ /* PMGL chunks only, search from first_pmgl to last_pmgl */
+ for (n = chm->first_pmgl; n <= chm->last_pmgl;
+ n = EndGetI32(&chunk[pmgl_NextChunk]))
+ {
+ if (!(chunk = read_chunk(self, chm, fh, n))) {
+ err = self->error;
+ break;
+ }
+
+ /* search PMGL chunk. exit if file found */
+ if ((result = search_chunk(chm, chunk, filename, &p, &end)) > 0) {
+ break;
+ }
+ }
+ }
+
+ /* if we found a file, read it */
+ if (result > 0) {
+ READ_ENCINT(sec);
+ f_ptr->section = (sec == 0) ? (struct mschmd_section *) &chm->sec0
+ : (struct mschmd_section *) &chm->sec1;
+ READ_ENCINT(f_ptr->offset);
+ READ_ENCINT(f_ptr->length);
+ }
+ else if (result < 0) {
+ err = MSPACK_ERR_DATAFORMAT;
+ }
+
+ sys->close(fh);
+ return self->error = err;
+
+ chunk_end:
+ D(("read beyond end of chunk entries"))
+ sys->close(fh);
+ return self->error = MSPACK_ERR_DATAFORMAT;
+}
+
+/* reads the given chunk into memory, storing it in a chunk cache
+ * so it doesn't need to be read from disk more than once
+ */
+static unsigned char *read_chunk(struct mschm_decompressor_p *self,
+ struct mschmd_header *chm,
+ struct mspack_file *fh,
+ unsigned int chunk_num)
+{
+ struct mspack_system *sys = self->system;
+ unsigned char *buf;
+
+ /* check arguments - most are already checked by chmd_fast_find */
+ if (chunk_num > chm->num_chunks) return NULL;
+
+ /* ensure chunk cache is available */
+ if (!chm->chunk_cache) {
+ size_t size = sizeof(unsigned char *) * chm->num_chunks;
+ if (!(chm->chunk_cache = (unsigned char **) sys->alloc(sys, size))) {
+ self->error = MSPACK_ERR_NOMEMORY;
+ return NULL;
+ }
+ memset(chm->chunk_cache, 0, size);
+ }
+
+ /* try to answer out of chunk cache */
+ if (chm->chunk_cache[chunk_num]) return chm->chunk_cache[chunk_num];
+
+ /* need to read chunk - allocate memory for it */
+ if (!(buf = (unsigned char *) sys->alloc(sys, chm->chunk_size))) {
+ self->error = MSPACK_ERR_NOMEMORY;
+ return NULL;
+ }
+
+ /* seek to block and read it */
+ if (sys->seek(fh, (off_t) (chm->dir_offset + (chunk_num * chm->chunk_size)),
+ MSPACK_SYS_SEEK_START))
+ {
+ self->error = MSPACK_ERR_SEEK;
+ sys->free(buf);
+ return NULL;
+ }
+ if (sys->read(fh, buf, (int)chm->chunk_size) != (int)chm->chunk_size) {
+ self->error = MSPACK_ERR_READ;
+ sys->free(buf);
+ return NULL;
+ }
+
+ /* check the signature. Is is PMGL or PMGI? */
+ if (!((buf[0] == 0x50) && (buf[1] == 0x4D) && (buf[2] == 0x47) &&
+ ((buf[3] == 0x4C) || (buf[3] == 0x49))))
+ {
+ self->error = MSPACK_ERR_SEEK;
+ sys->free(buf);
+ return NULL;
+ }
+
+ /* all OK. Store chunk in cache and return it */
+ return chm->chunk_cache[chunk_num] = buf;
+}
+
+/* searches a PMGI/PMGL chunk for a given filename entry. Returns -1 on
+ * data format error, 0 if entry definitely not found, 1 if entry
+ * found. In the latter case, *result and *result_end are set pointing
+ * to that entry's data (either the "next chunk" ENCINT for a PMGI or
+ * the section, offset and length ENCINTs for a PMGL).
+ *
+ * In the case of PMGL chunks, the entry has definitely been
+ * found. In the case of PMGI chunks, the entry which points to the
+ * chunk that may eventually contain that entry has been found.
+ */
+static int search_chunk(struct mschmd_header *chm,
+ const unsigned char *chunk,
+ const char *filename,
+ const unsigned char **result,
+ const unsigned char **result_end)
+{
+ const unsigned char *start, *end, *p;
+ unsigned int qr_size, num_entries, qr_entries, qr_density, name_len;
+ unsigned int L, R, M, sec, fname_len, entries_off, is_pmgl;
+ int cmp;
+
+ fname_len = strlen(filename);
+
+ /* PMGL chunk or PMGI chunk? (note: read_chunk() has already
+ * checked the rest of the characters in the chunk signature) */
+ if (chunk[3] == 0x4C) {
+ is_pmgl = 1;
+ entries_off = pmgl_Entries;
+ }
+ else {
+ is_pmgl = 0;
+ entries_off = pmgi_Entries;
+ }
+
+ /* Step 1: binary search first filename of each QR entry
+ * - target filename == entry
+ * found file
+ * - target filename < all entries
+ * file not found
+ * - target filename > all entries
+ * proceed to step 2 using final entry
+ * - target filename between two searched entries
+ * proceed to step 2
+ */
+ qr_size = EndGetI32(&chunk[pmgl_QuickRefSize]);
+ start = &chunk[chm->chunk_size - 2];
+ end = &chunk[chm->chunk_size - qr_size];
+ num_entries = EndGetI16(start);
+ qr_density = 1 + (1 << chm->density);
+ qr_entries = (num_entries + qr_density-1) / qr_density;
+
+ if (num_entries == 0) {
+ D(("chunk has no entries"))
+ return -1;
+ }
+
+ if (qr_size > chm->chunk_size) {
+ D(("quickref size > chunk size"))
+ return -1;
+ }
+
+ *result_end = end;
+
+ if (((int)qr_entries * 2) > (start - end)) {
+ D(("WARNING; more quickrefs than quickref space"))
+ qr_entries = 0; /* but we can live with it */
+ }
+
+ if (qr_entries > 0) {
+ L = 0;
+ R = qr_entries - 1;
+ do {
+ /* pick new midpoint */
+ M = (L + R) >> 1;
+
+ /* compare filename with entry QR points to */
+ p = &chunk[entries_off + (M ? EndGetI16(start - (M << 1)) : 0)];
+ READ_ENCINT(name_len);
+ if (p + name_len > end) goto chunk_end;
+ cmp = compare(filename, (char *)p, fname_len, name_len);
+
+ if (cmp == 0) break;
+ else if (cmp < 0) { if (M) R = M - 1; else return 0; }
+ else if (cmp > 0) L = M + 1;
+ } while (L <= R);
+ M = (L + R) >> 1;
+
+ if (cmp == 0) {
+ /* exact match! */
+ p += name_len;
+ *result = p;
+ return 1;
+ }
+
+ /* otherwise, read the group of entries for QR entry M */
+ p = &chunk[entries_off + (M ? EndGetI16(start - (M << 1)) : 0)];
+ num_entries -= (M * qr_density);
+ if (num_entries > qr_density) num_entries = qr_density;
+ }
+ else {
+ p = &chunk[entries_off];
+ }
+
+ /* Step 2: linear search through the set of entries reached in step 1.
+ * - filename == any entry
+ * found entry
+ * - filename < all entries (PMGI) or any entry (PMGL)
+ * entry not found, stop now
+ * - filename > all entries
+ * entry not found (PMGL) / maybe found (PMGI)
+ * -
+ */
+ *result = NULL;
+ while (num_entries-- > 0) {
+ READ_ENCINT(name_len);
+ if (p + name_len > end) goto chunk_end;
+ cmp = compare(filename, (char *)p, fname_len, name_len);
+ p += name_len;
+
+ if (cmp == 0) {
+ /* entry found */
+ *result = p;
+ return 1;
+ }
+
+ if (cmp < 0) {
+ /* entry not found (PMGL) / maybe found (PMGI) */
+ break;
+ }
+
+ /* read and ignore the rest of this entry */
+ if (is_pmgl) {
+ READ_ENCINT(R); /* skip section */
+ READ_ENCINT(R); /* skip offset */
+ READ_ENCINT(R); /* skip length */
+ }
+ else {
+ *result = p; /* store potential final result */
+ READ_ENCINT(R); /* skip chunk number */
+ }
+ }
+
+ /* PMGL? not found. PMGI? maybe found */
+ return (is_pmgl) ? 0 : (*result ? 1 : 0);
+
+ chunk_end:
+ D(("reached end of chunk data while searching"))
+ return -1;
+}
+
+#if HAVE_TOWLOWER
+# if HAVE_WCTYPE_H
+# include <wctype.h>
+# endif
+# define TOLOWER(x) towlower(x)
+#elif HAVE_TOLOWER
+# if HAVE_CTYPE_H
+# include <ctype.h>
+# endif
+# define TOLOWER(x) tolower(x)
+#else
+# define TOLOWER(x) (((x)<0||(x)>256)?(x):mspack_tolower_map[(x)])
+/* Map of char -> lowercase char for the first 256 chars. Generated with:
+ * LC_CTYPE=en_GB.utf-8 perl -Mlocale -le 'print map{ord(lc chr).","} 0..255'
+ */
+static const unsigned char mspack_tolower_map[256] = {
+ 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,
+ 28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,
+ 53,54,55,56,57,58,59,60,61,62,63,64,97,98,99,100,101,102,103,104,105,106,
+ 107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,91,92,93,94,
+ 95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,
+ 115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,
+ 134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,
+ 153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,
+ 172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,
+ 191,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,
+ 242,243,244,245,246,215,248,249,250,251,252,253,254,223,224,225,226,227,228,
+ 229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,
+ 248,249,250,251,252,253,254,255
+};
+#endif
+
+/* decodes a UTF-8 character from s[] into c. Will not read past e. */
+#define GET_UTF8_CHAR(s, e, c) do { \
+ unsigned char x = *s++; \
+ if (x < 0x80) c = x; \
+ else if (x < 0xC0) c = -1; \
+ else if (x < 0xE0) { \
+ c = (s >= e) ? -1 : ((x & 0x1F) << 6) | (*s++ & 0x3F); \
+ } \
+ else if (x < 0xF0) { \
+ c = (s+2 > e) ? -1 : ((x & 0x0F) << 12) | ((s[0] & 0x3F) << 6) \
+ | (s[1] & 0x3F); \
+ s += 2; \
+ } \
+ else if (x < 0xF8) { \
+ c = (s+3 > e) ? -1 : ((x & 0x07) << 18) | ((s[0] & 0x3F) << 12) \
+ | ((s[1] & 0x3F) << 6) | (s[2] & 0x3F); \
+ s += 3; \
+ } \
+ else if (x < 0xFC) { \
+ c = (s+4 > e) ? -1 : ((x & 0x03) << 24) | ((s[0] & 0x3F) << 18) \
+ | ((s[1] & 0x3F) << 12)|((s[2] & 0x3F) << 6)|(s[3] & 0x3F); \
+ s += 4; \
+ } \
+ else if (x < 0xFE) { \
+ c = (s+5>e)?-1:((x&1)<<30)|((s[0]&0x3F)<<24)|((s[1]&0x3F)<<18)| \
+ ((s[2] & 0x3F) << 12) | ((s[3] & 0x3F) << 6)|(s[4] & 0x3F); \
+ s += 5; \
+ } \
+ else c = -1; \
+} while (0)
+
+/* case-insensitively compares two UTF8 encoded strings. String length for
+ * both strings must be provided, null bytes are not terminators */
+static inline int compare(const char *s1, const char *s2, int l1, int l2) {
+ register const unsigned char *p1 = (const unsigned char *) s1;
+ register const unsigned char *p2 = (const unsigned char *) s2;
+ register const unsigned char *e1 = p1 + l1, *e2 = p2 + l2;
+ int c1, c2;
+
+ while (p1 < e1 && p2 < e2) {
+ GET_UTF8_CHAR(p1, e1, c1);
+ GET_UTF8_CHAR(p2, e2, c2);
+ if (c1 == c2) continue;
+ c1 = TOLOWER(c1);
+ c2 = TOLOWER(c2);
+ if (c1 != c2) return c1 - c2;
+ }
+ return l1 - l2;
+}
+
+
+/***************************************
+ * CHMD_EXTRACT
+ ***************************************
+ * extracts a file from a CHM helpfile
+ */
+static int chmd_extract(struct mschm_decompressor *base,
+ struct mschmd_file *file, const char *filename)
+{
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ struct mspack_system *sys;
+ struct mschmd_header *chm;
+ struct mspack_file *fh;
+ off_t bytes;
+
+ if (!self) return MSPACK_ERR_ARGS;
+ if (!file || !file->section) return self->error = MSPACK_ERR_ARGS;
+ sys = self->system;
+ chm = file->section->chm;
+
+ /* create decompression state if it doesn't exist */
+ if (!self->d) {
+ self->d = (struct mschmd_decompress_state *) sys->alloc(sys, sizeof(struct mschmd_decompress_state));
+ if (!self->d) return self->error = MSPACK_ERR_NOMEMORY;
+ self->d->chm = chm;
+ self->d->offset = 0;
+ self->d->state = NULL;
+ self->d->sys = *sys;
+ self->d->sys.write = &chmd_sys_write;
+ self->d->infh = NULL;
+ self->d->outfh = NULL;
+ }
+
+ /* open input chm file if not open, or the open one is a different chm */
+ if (!self->d->infh || (self->d->chm != chm)) {
+ if (self->d->infh) sys->close(self->d->infh);
+ if (self->d->state) lzxd_free(self->d->state);
+ self->d->chm = chm;
+ self->d->offset = 0;
+ self->d->state = NULL;
+ self->d->infh = sys->open(sys, chm->filename, MSPACK_SYS_OPEN_READ);
+ if (!self->d->infh) return self->error = MSPACK_ERR_OPEN;
+ }
+
+ /* open file for output */
+ if (!(fh = sys->open(sys, filename, MSPACK_SYS_OPEN_WRITE))) {
+ return self->error = MSPACK_ERR_OPEN;
+ }
+
+ /* if file is empty, simply creating it is enough */
+ if (!file->length) {
+ sys->close(fh);
+ return self->error = MSPACK_ERR_OK;
+ }
+
+ self->error = MSPACK_ERR_OK;
+
+ switch (file->section->id) {
+ case 0: /* Uncompressed section file */
+ /* simple seek + copy */
+ if (sys->seek(self->d->infh, file->section->chm->sec0.offset
+ + file->offset, MSPACK_SYS_SEEK_START))
+ {
+ self->error = MSPACK_ERR_SEEK;
+ }
+ else {
+ unsigned char buf[512];
+ off_t length = file->length;
+ while (length > 0) {
+ int run = sizeof(buf);
+ if ((off_t)run > length) run = (int)length;
+ if (sys->read(self->d->infh, &buf[0], run) != run) {
+ self->error = MSPACK_ERR_READ;
+ break;
+ }
+ if (sys->write(fh, &buf[0], run) != run) {
+ self->error = MSPACK_ERR_WRITE;
+ break;
+ }
+ length -= run;
+ }
+ }
+ break;
+
+ case 1: /* MSCompressed section file */
+ /* (re)initialise compression state if we it is not yet initialised,
+ * or we have advanced too far and have to backtrack
+ */
+ if (!self->d->state || (file->offset < self->d->offset)) {
+ if (self->d->state) {
+ lzxd_free(self->d->state);
+ self->d->state = NULL;
+ }
+ if (chmd_init_decomp(self, file)) break;
+ }
+
+ /* seek to input data */
+ if (sys->seek(self->d->infh, self->d->inoffset, MSPACK_SYS_SEEK_START)) {
+ self->error = MSPACK_ERR_SEEK;
+ break;
+ }
+
+ /* get to correct offset. */
+ self->d->outfh = NULL;
+ if ((bytes = file->offset - self->d->offset)) {
+ self->error = lzxd_decompress(self->d->state, bytes);
+ }
+
+ /* if getting to the correct offset was error free, unpack file */
+ if (!self->error) {
+ self->d->outfh = fh;
+ self->error = lzxd_decompress(self->d->state, file->length);
+ }
+
+ /* save offset in input source stream, in case there is a section 0
+ * file between now and the next section 1 file extracted */
+ self->d->inoffset = sys->tell(self->d->infh);
+
+ /* if an LZX error occured, the LZX decompressor is now useless */
+ if (self->error) {
+ if (self->d->state) lzxd_free(self->d->state);
+ self->d->state = NULL;
+ }
+ break;
+ }
+
+ sys->close(fh);
+ return self->error;
+}
+
+/***************************************
+ * CHMD_SYS_WRITE
+ ***************************************
+ * chmd_sys_write is the internal writer function which the decompressor
+ * uses. If either writes data to disk (self->d->outfh) with the real
+ * sys->write() function, or does nothing with the data when
+ * self->d->outfh == NULL. advances self->d->offset.
+ */
+static int chmd_sys_write(struct mspack_file *file, void *buffer, int bytes) {
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) file;
+ self->d->offset += bytes;
+ if (self->d->outfh) {
+ return self->system->write(self->d->outfh, buffer, bytes);
+ }
+ return bytes;
+}
+
+/***************************************
+ * CHMD_INIT_DECOMP
+ ***************************************
+ * Initialises the LZX decompressor to decompress the compressed stream,
+ * from the nearest reset offset and length that is needed for the given
+ * file.
+ */
+static int chmd_init_decomp(struct mschm_decompressor_p *self,
+ struct mschmd_file *file)
+{
+ int window_size, window_bits, reset_interval, entry, err;
+ struct mspack_system *sys = self->system;
+ struct mschmd_sec_mscompressed *sec;
+ unsigned char *data;
+ off_t length, offset;
+
+ sec = (struct mschmd_sec_mscompressed *) file->section;
+
+ /* ensure we have a mscompressed content section */
+ err = find_sys_file(self, sec, &sec->content, content_name);
+ if (err) return self->error = err;
+
+ /* ensure we have a ControlData file */
+ err = find_sys_file(self, sec, &sec->control, control_name);
+ if (err) return self->error = err;
+
+ /* read ControlData */
+ if (sec->control->length < lzxcd_SIZEOF) {
+ D(("ControlData file is too short"))
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+ if (!(data = read_sys_file(self, sec->control))) {
+ D(("can't read mscompressed control data file"))
+ return self->error;
+ }
+
+ /* check LZXC signature */
+ if (EndGetI32(&data[lzxcd_Signature]) != 0x43585A4C) {
+ sys->free(data);
+ return self->error = MSPACK_ERR_SIGNATURE;
+ }
+
+ /* read reset_interval and window_size and validate version number */
+ switch (EndGetI32(&data[lzxcd_Version])) {
+ case 1:
+ reset_interval = EndGetI32(&data[lzxcd_ResetInterval]);
+ window_size = EndGetI32(&data[lzxcd_WindowSize]);
+ break;
+ case 2:
+ reset_interval = EndGetI32(&data[lzxcd_ResetInterval]) * LZX_FRAME_SIZE;
+ window_size = EndGetI32(&data[lzxcd_WindowSize]) * LZX_FRAME_SIZE;
+ break;
+ default:
+ D(("bad controldata version"))
+ sys->free(data);
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* free ControlData */
+ sys->free(data);
+
+ /* find window_bits from window_size */
+ switch (window_size) {
+ case 0x008000: window_bits = 15; break;
+ case 0x010000: window_bits = 16; break;
+ case 0x020000: window_bits = 17; break;
+ case 0x040000: window_bits = 18; break;
+ case 0x080000: window_bits = 19; break;
+ case 0x100000: window_bits = 20; break;
+ case 0x200000: window_bits = 21; break;
+ default:
+ D(("bad controldata window size"))
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* validate reset_interval */
+ if (reset_interval % LZX_FRAME_SIZE) {
+ D(("bad controldata reset interval"))
+ return self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* which reset table entry would we like? */
+ entry = file->offset / reset_interval;
+ /* convert from reset interval multiple (usually 64k) to 32k frames */
+ entry *= reset_interval / LZX_FRAME_SIZE;
+
+ /* read the reset table entry */
+ if (read_reset_table(self, sec, entry, &length, &offset)) {
+ /* the uncompressed length given in the reset table is dishonest.
+ * the uncompressed data is always padded out from the given
+ * uncompressed length up to the next reset interval */
+ length += reset_interval - 1;
+ length &= -reset_interval;
+ }
+ else {
+ /* if we can't read the reset table entry, just start from
+ * the beginning. Use spaninfo to get the uncompressed length */
+ entry = 0;
+ offset = 0;
+ err = read_spaninfo(self, sec, &length);
+ }
+ if (err) return self->error = err;
+
+ /* get offset of compressed data stream:
+ * = offset of uncompressed section from start of file
+ * + offset of compressed stream from start of uncompressed section
+ * + offset of chosen reset interval from start of compressed stream */
+ self->d->inoffset = file->section->chm->sec0.offset + sec->content->offset + offset;
+
+ /* set start offset and overall remaining stream length */
+ self->d->offset = entry * LZX_FRAME_SIZE;
+ length -= self->d->offset;
+
+ /* initialise LZX stream */
+ self->d->state = lzxd_init(&self->d->sys, self->d->infh,
+ (struct mspack_file *) self, window_bits,
+ reset_interval / LZX_FRAME_SIZE,
+ 4096, length);
+ if (!self->d->state) self->error = MSPACK_ERR_NOMEMORY;
+ return self->error;
+}
+
+/***************************************
+ * READ_RESET_TABLE
+ ***************************************
+ * Reads one entry out of the reset table. Also reads the uncompressed
+ * data length. Writes these to offset_ptr and length_ptr respectively.
+ * Returns non-zero for success, zero for failure.
+ */
+static int read_reset_table(struct mschm_decompressor_p *self,
+ struct mschmd_sec_mscompressed *sec,
+ int entry, off_t *length_ptr, off_t *offset_ptr)
+{
+ struct mspack_system *sys = self->system;
+ unsigned char *data;
+ int pos, entrysize;
+
+ /* do we have a ResetTable file? */
+ int err = find_sys_file(self, sec, &sec->rtable, rtable_name);
+ if (err) return 0;
+
+ /* read ResetTable file */
+ if (sec->rtable->length < lzxrt_headerSIZEOF) {
+ D(("ResetTable file is too short"))
+ return 0;
+ }
+ if (!(data = read_sys_file(self, sec->rtable))) {
+ D(("can't read reset table"))
+ return 0;
+ }
+
+ /* check sanity of reset table */
+ if (EndGetI32(&data[lzxrt_FrameLen]) != LZX_FRAME_SIZE) {
+ D(("bad reset table frame length"))
+ sys->free(data);
+ return 0;
+ }
+
+ /* get the uncompressed length of the LZX stream */
+ if (read_off64(length_ptr, data, sys, self->d->infh)) {
+ sys->free(data);
+ return 0;
+ }
+
+ entrysize = EndGetI32(&data[lzxrt_EntrySize]);
+ pos = EndGetI32(&data[lzxrt_TableOffset]) + (entry * entrysize);
+
+ /* ensure reset table entry for this offset exists */
+ if (entry < EndGetI32(&data[lzxrt_NumEntries]) &&
+ ((pos + entrysize) <= sec->rtable->length))
+ {
+ switch (entrysize) {
+ case 4:
+ *offset_ptr = EndGetI32(&data[pos]);
+ err = 0;
+ break;
+ case 8:
+ err = read_off64(offset_ptr, &data[pos], sys, self->d->infh);
+ break;
+ default:
+ D(("reset table entry size neither 4 nor 8"))
+ err = 1;
+ break;
+ }
+ }
+ else {
+ D(("bad reset interval"))
+ err = 1;
+ }
+
+ /* free the reset table */
+ sys->free(data);
+
+ /* return success */
+ return (err == 0);
+}
+
+/***************************************
+ * READ_SPANINFO
+ ***************************************
+ * Reads the uncompressed data length from the spaninfo file.
+ * Returns zero for success or a non-zero error code for failure.
+ */
+static int read_spaninfo(struct mschm_decompressor_p *self,
+ struct mschmd_sec_mscompressed *sec,
+ off_t *length_ptr)
+{
+ struct mspack_system *sys = self->system;
+ unsigned char *data;
+
+ /* find SpanInfo file */
+ int err = find_sys_file(self, sec, &sec->spaninfo, spaninfo_name);
+ if (err) return MSPACK_ERR_DATAFORMAT;
+
+ /* check it's large enough */
+ if (sec->spaninfo->length != 8) {
+ D(("SpanInfo file is wrong size"))
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* read the SpanInfo file */
+ if (!(data = read_sys_file(self, sec->spaninfo))) {
+ D(("can't read SpanInfo file"))
+ return self->error;
+ }
+
+ /* get the uncompressed length of the LZX stream */
+ err = read_off64(length_ptr, data, sys, self->d->infh);
+
+ sys->free(data);
+ return (err) ? MSPACK_ERR_DATAFORMAT : MSPACK_ERR_OK;
+}
+
+/***************************************
+ * FIND_SYS_FILE
+ ***************************************
+ * Uses chmd_fast_find to locate a system file, and fills out that system
+ * file's entry and links it into the list of system files. Returns zero
+ * for success, non-zero for both failure and the file not existing.
+ */
+static int find_sys_file(struct mschm_decompressor_p *self,
+ struct mschmd_sec_mscompressed *sec,
+ struct mschmd_file **f_ptr, const char *name)
+{
+ struct mspack_system *sys = self->system;
+ struct mschmd_file result;
+
+ /* already loaded */
+ if (*f_ptr) return MSPACK_ERR_OK;
+
+ /* try using fast_find to find the file - return DATAFORMAT error if
+ * it fails, or successfully doesn't find the file */
+ if (chmd_fast_find((struct mschm_decompressor *) self, sec->base.chm,
+ name, &result, (int)sizeof(result)) || !result.section)
+ {
+ return MSPACK_ERR_DATAFORMAT;
+ }
+
+ if (!(*f_ptr = (struct mschmd_file *) sys->alloc(sys, sizeof(result)))) {
+ return MSPACK_ERR_NOMEMORY;
+ }
+
+ /* copy result */
+ *(*f_ptr) = result;
+ (*f_ptr)->filename = (char *) name;
+
+ /* link file into sysfiles list */
+ (*f_ptr)->next = sec->base.chm->sysfiles;
+ sec->base.chm->sysfiles = *f_ptr;
+ return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * READ_SYS_FILE
+ ***************************************
+ * Allocates memory for a section 0 (uncompressed) file and reads it into
+ * memory.
+ */
+static unsigned char *read_sys_file(struct mschm_decompressor_p *self,
+ struct mschmd_file *file)
+{
+ struct mspack_system *sys = self->system;
+ unsigned char *data = NULL;
+ int len;
+
+ if (!file || !file->section || (file->section->id != 0)) {
+ self->error = MSPACK_ERR_DATAFORMAT;
+ return NULL;
+ }
+
+ len = (int) file->length;
+
+ if (!(data = (unsigned char *) sys->alloc(sys, (size_t) len))) {
+ self->error = MSPACK_ERR_NOMEMORY;
+ return NULL;
+ }
+ if (sys->seek(self->d->infh, file->section->chm->sec0.offset
+ + file->offset, MSPACK_SYS_SEEK_START))
+ {
+ self->error = MSPACK_ERR_SEEK;
+ sys->free(data);
+ return NULL;
+ }
+ if (sys->read(self->d->infh, data, len) != len) {
+ self->error = MSPACK_ERR_READ;
+ sys->free(data);
+ return NULL;
+ }
+ return data;
+}
+
+/***************************************
+ * CHMD_ERROR
+ ***************************************
+ * returns the last error that occurred
+ */
+static int chmd_error(struct mschm_decompressor *base) {
+ struct mschm_decompressor_p *self = (struct mschm_decompressor_p *) base;
+ return (self) ? self->error : MSPACK_ERR_ARGS;
+}
+
+/***************************************
+ * READ_OFF64
+ ***************************************
+ * Reads a 64-bit signed integer from memory in Intel byte order.
+ * If running on a system with a 64-bit off_t, this is simply done.
+ * If running on a system with a 32-bit off_t, offsets up to 0x7FFFFFFF
+ * are accepted, offsets beyond that cause an error message.
+ */
+static int read_off64(off_t *var, unsigned char *mem,
+ struct mspack_system *sys, struct mspack_file *fh)
+{
+#ifdef LARGEFILE_SUPPORT
+ *var = EndGetI64(mem);
+#else
+ *var = EndGetI32(mem);
+ if ((*var & 0x80000000) || EndGetI32(mem+4)) {
+ sys->message(fh, (char *)largefile_msg);
+ return 1;
+ }
+#endif
+ return 0;
+}
diff --git a/rbutil/rbutilqt/mspack/des.h b/rbutil/rbutilqt/mspack/des.h
new file mode 100644
index 0000000000..64a1ed27e4
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/des.h
@@ -0,0 +1,15 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_DES_H
+#define MSPACK_DES_H 1
+
+/* DES encryption / decryption definitions */
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/hlp.h b/rbutil/rbutilqt/mspack/hlp.h
new file mode 100644
index 0000000000..b7486fa160
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/hlp.h
@@ -0,0 +1,33 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_HLP_H
+#define MSPACK_HLP_H 1
+
+#include <lzss.h>
+
+/* generic HLP definitions */
+
+/* HLP compression definitions */
+
+struct mshlp_compressor_p {
+ struct mshlp_compressor base;
+ struct mspack_system *system;
+ /* todo */
+};
+
+/* HLP decompression definitions */
+
+struct mshlp_decompressor_p {
+ struct mshlp_decompressor base;
+ struct mspack_system *system;
+ /* todo */
+};
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/hlpc.c b/rbutil/rbutilqt/mspack/hlpc.c
new file mode 100644
index 0000000000..60eabfe207
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/hlpc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* HLP compression implementation */
+
+#include <system.h>
+#include <hlp.h>
+
+struct mshlp_compressor *
+ mspack_create_hlp_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_hlp_compressor(struct mshlp_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/hlpd.c b/rbutil/rbutilqt/mspack/hlpd.c
new file mode 100644
index 0000000000..43354f008f
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/hlpd.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* HLP decompression implementation */
+
+#include <system.h>
+#include <hlp.h>
+
+struct mshlp_decompressor *
+ mspack_create_hlp_decompressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_hlp_decompressor(struct mshlp_decompressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/kwaj.h b/rbutil/rbutilqt/mspack/kwaj.h
new file mode 100644
index 0000000000..09673c0779
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/kwaj.h
@@ -0,0 +1,118 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_KWAJ_H
+#define MSPACK_KWAJ_H 1
+
+#include <lzss.h>
+
+/* generic KWAJ definitions */
+#define kwajh_Signature1 (0x00)
+#define kwajh_Signature2 (0x04)
+#define kwajh_CompMethod (0x08)
+#define kwajh_DataOffset (0x0a)
+#define kwajh_Flags (0x0c)
+#define kwajh_SIZEOF (0x0e)
+
+/* KWAJ compression definitions */
+
+struct mskwaj_compressor_p {
+ struct mskwaj_compressor base;
+ struct mspack_system *system;
+ /* todo */
+ int param[2]; /* !!! MATCH THIS TO NUM OF PARAMS IN MSPACK.H !!! */
+ int error;
+};
+
+/* KWAJ decompression definitions */
+
+struct mskwaj_decompressor_p {
+ struct mskwaj_decompressor base;
+ struct mspack_system *system;
+ int error;
+};
+
+struct mskwajd_header_p {
+ struct mskwajd_header base;
+ struct mspack_file *fh;
+};
+
+/* input buffer size during decompression - not worth parameterising IMHO */
+#define KWAJ_INPUT_SIZE (2048)
+
+/* huffman codes that are 9 bits or less are decoded immediately */
+#define KWAJ_TABLEBITS (9)
+
+/* number of codes in each huffman table */
+#define KWAJ_MATCHLEN1_SYMS (16)
+#define KWAJ_MATCHLEN2_SYMS (16)
+#define KWAJ_LITLEN_SYMS (32)
+#define KWAJ_OFFSET_SYMS (64)
+#define KWAJ_LITERAL_SYMS (256)
+
+/* define decoding table sizes */
+#define KWAJ_TABLESIZE (1 << KWAJ_TABLEBITS)
+#if KWAJ_TABLESIZE < (KWAJ_MATCHLEN1_SYMS * 2)
+# define KWAJ_MATCHLEN1_TBLSIZE (KWAJ_MATCHLEN1_SYMS * 4)
+#else
+# define KWAJ_MATCHLEN1_TBLSIZE (KWAJ_TABLESIZE + (KWAJ_MATCHLEN1_SYMS * 2))
+#endif
+#if KWAJ_TABLESIZE < (KWAJ_MATCHLEN2_SYMS * 2)
+# define KWAJ_MATCHLEN2_TBLSIZE (KWAJ_MATCHLEN2_SYMS * 4)
+#else
+# define KWAJ_MATCHLEN2_TBLSIZE (KWAJ_TABLESIZE + (KWAJ_MATCHLEN2_SYMS * 2))
+#endif
+#if KWAJ_TABLESIZE < (KWAJ_LITLEN_SYMS * 2)
+# define KWAJ_LITLEN_TBLSIZE (KWAJ_LITLEN_SYMS * 4)
+#else
+# define KWAJ_LITLEN_TBLSIZE (KWAJ_TABLESIZE + (KWAJ_LITLEN_SYMS * 2))
+#endif
+#if KWAJ_TABLESIZE < (KWAJ_OFFSET_SYMS * 2)
+# define KWAJ_OFFSET_TBLSIZE (KWAJ_OFFSET_SYMS * 4)
+#else
+# define KWAJ_OFFSET_TBLSIZE (KWAJ_TABLESIZE + (KWAJ_OFFSET_SYMS * 2))
+#endif
+#if KWAJ_TABLESIZE < (KWAJ_LITERAL_SYMS * 2)
+# define KWAJ_LITERAL_TBLSIZE (KWAJ_LITERAL_SYMS * 4)
+#else
+# define KWAJ_LITERAL_TBLSIZE (KWAJ_TABLESIZE + (KWAJ_LITERAL_SYMS * 2))
+#endif
+
+struct kwajd_stream {
+ /* I/O buffering */
+ struct mspack_system *sys;
+ struct mspack_file *input;
+ struct mspack_file *output;
+ unsigned char *i_ptr, *i_end;
+ unsigned int bit_buffer, bits_left;
+ int input_end;
+
+ /* huffman code lengths */
+ unsigned char MATCHLEN1_len [KWAJ_MATCHLEN1_SYMS];
+ unsigned char MATCHLEN2_len [KWAJ_MATCHLEN2_SYMS];
+ unsigned char LITLEN_len [KWAJ_LITLEN_SYMS];
+ unsigned char OFFSET_len [KWAJ_OFFSET_SYMS];
+ unsigned char LITERAL_len [KWAJ_LITERAL_SYMS];
+
+ /* huffman decoding tables */
+ unsigned short MATCHLEN1_table [KWAJ_MATCHLEN1_TBLSIZE];
+ unsigned short MATCHLEN2_table [KWAJ_MATCHLEN2_TBLSIZE];
+ unsigned short LITLEN_table [KWAJ_LITLEN_TBLSIZE];
+ unsigned short OFFSET_table [KWAJ_OFFSET_TBLSIZE];
+ unsigned short LITERAL_table [KWAJ_LITERAL_TBLSIZE];
+
+ /* input buffer */
+ unsigned char inbuf[KWAJ_INPUT_SIZE];
+
+ /* history window */
+ unsigned char window[LZSS_WINDOW_SIZE];
+};
+
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/kwajc.c b/rbutil/rbutilqt/mspack/kwajc.c
new file mode 100644
index 0000000000..b88ed7690a
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/kwajc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* KWAJ compression implementation */
+
+#include <system.h>
+#include <kwaj.h>
+
+struct mskwaj_compressor *
+ mspack_create_kwaj_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_kwaj_compressor(struct mskwaj_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/kwajd.c b/rbutil/rbutilqt/mspack/kwajd.c
new file mode 100644
index 0000000000..d891b6a7e3
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/kwajd.c
@@ -0,0 +1,555 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * KWAJ is a format very similar to SZDD. KWAJ method 3 (LZH) was
+ * written by Jeff Johnson.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* KWAJ decompression implementation */
+
+#include <system.h>
+#include <kwaj.h>
+
+/* prototypes */
+static struct mskwajd_header *kwajd_open(
+ struct mskwaj_decompressor *base, const char *filename);
+static void kwajd_close(
+ struct mskwaj_decompressor *base, struct mskwajd_header *hdr);
+static int kwajd_read_headers(
+ struct mspack_system *sys, struct mspack_file *fh,
+ struct mskwajd_header *hdr);
+static int kwajd_extract(
+ struct mskwaj_decompressor *base, struct mskwajd_header *hdr,
+ const char *filename);
+static int kwajd_decompress(
+ struct mskwaj_decompressor *base, const char *input, const char *output);
+static int kwajd_error(
+ struct mskwaj_decompressor *base);
+
+static struct kwajd_stream *lzh_init(
+ struct mspack_system *sys, struct mspack_file *in, struct mspack_file *out);
+static int lzh_decompress(
+ struct kwajd_stream *kwaj);
+static void lzh_free(
+ struct kwajd_stream *kwaj);
+static int lzh_read_lens(
+ struct kwajd_stream *kwaj,
+ unsigned int type, unsigned int numsyms,
+ unsigned char *lens, unsigned short *table);
+static int lzh_read_input(
+ struct kwajd_stream *kwaj);
+
+
+/***************************************
+ * MSPACK_CREATE_KWAJ_DECOMPRESSOR
+ ***************************************
+ * constructor
+ */
+struct mskwaj_decompressor *
+ mspack_create_kwaj_decompressor(struct mspack_system *sys)
+{
+ struct mskwaj_decompressor_p *self = NULL;
+
+ if (!sys) sys = mspack_default_system;
+ if (!mspack_valid_system(sys)) return NULL;
+
+ if ((self = (struct mskwaj_decompressor_p *) sys->alloc(sys, sizeof(struct mskwaj_decompressor_p)))) {
+ self->base.open = &kwajd_open;
+ self->base.close = &kwajd_close;
+ self->base.extract = &kwajd_extract;
+ self->base.decompress = &kwajd_decompress;
+ self->base.last_error = &kwajd_error;
+ self->system = sys;
+ self->error = MSPACK_ERR_OK;
+ }
+ return (struct mskwaj_decompressor *) self;
+}
+
+/***************************************
+ * MSPACK_DESTROY_KWAJ_DECOMPRESSOR
+ ***************************************
+ * destructor
+ */
+void mspack_destroy_kwaj_decompressor(struct mskwaj_decompressor *base)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ if (self) {
+ struct mspack_system *sys = self->system;
+ sys->free(self);
+ }
+}
+
+/***************************************
+ * KWAJD_OPEN
+ ***************************************
+ * opens a KWAJ file without decompressing, reads header
+ */
+static struct mskwajd_header *kwajd_open(struct mskwaj_decompressor *base,
+ const char *filename)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ struct mskwajd_header *hdr;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+
+ if (!self) return NULL;
+ sys = self->system;
+
+ fh = sys->open(sys, filename, MSPACK_SYS_OPEN_READ);
+ hdr = (struct mskwajd_header *) sys->alloc(sys, sizeof(struct mskwajd_header_p));
+ if (fh && hdr) {
+ ((struct mskwajd_header_p *) hdr)->fh = fh;
+ self->error = kwajd_read_headers(sys, fh, hdr);
+ }
+ else {
+ if (!fh) self->error = MSPACK_ERR_OPEN;
+ if (!hdr) self->error = MSPACK_ERR_NOMEMORY;
+ }
+
+ if (self->error) {
+ if (fh) sys->close(fh);
+ if (hdr) sys->free(hdr);
+ hdr = NULL;
+ }
+
+ return hdr;
+}
+
+/***************************************
+ * KWAJD_CLOSE
+ ***************************************
+ * closes a KWAJ file
+ */
+static void kwajd_close(struct mskwaj_decompressor *base,
+ struct mskwajd_header *hdr)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ struct mskwajd_header_p *hdr_p = (struct mskwajd_header_p *) hdr;
+
+ if (!self || !self->system) return;
+
+ /* close the file handle associated */
+ self->system->close(hdr_p->fh);
+
+ /* free the memory associated */
+ self->system->free(hdr);
+
+ self->error = MSPACK_ERR_OK;
+}
+
+/***************************************
+ * KWAJD_READ_HEADERS
+ ***************************************
+ * reads the headers of a KWAJ format file
+ */
+static int kwajd_read_headers(struct mspack_system *sys,
+ struct mspack_file *fh,
+ struct mskwajd_header *hdr)
+{
+ unsigned char buf[16];
+ int i;
+
+ /* read in the header */
+ if (sys->read(fh, &buf[0], kwajh_SIZEOF) != kwajh_SIZEOF) {
+ return MSPACK_ERR_READ;
+ }
+
+ /* check for "KWAJ" signature */
+ if (((unsigned int) EndGetI32(&buf[kwajh_Signature1]) != 0x4A41574B) ||
+ ((unsigned int) EndGetI32(&buf[kwajh_Signature2]) != 0xD127F088))
+ {
+ return MSPACK_ERR_SIGNATURE;
+ }
+
+ /* basic header fields */
+ hdr->comp_type = EndGetI16(&buf[kwajh_CompMethod]);
+ hdr->data_offset = EndGetI16(&buf[kwajh_DataOffset]);
+ hdr->headers = EndGetI16(&buf[kwajh_Flags]);
+ hdr->length = 0;
+ hdr->filename = NULL;
+ hdr->extra = NULL;
+ hdr->extra_length = 0;
+
+ /* optional headers */
+
+ /* 4 bytes: length of unpacked file */
+ if (hdr->headers & MSKWAJ_HDR_HASLENGTH) {
+ if (sys->read(fh, &buf[0], 4) != 4) return MSPACK_ERR_READ;
+ hdr->length = EndGetI32(&buf[0]);
+ }
+
+ /* 2 bytes: unknown purpose */
+ if (hdr->headers & MSKWAJ_HDR_HASUNKNOWN1) {
+ if (sys->read(fh, &buf[0], 2) != 2) return MSPACK_ERR_READ;
+ }
+
+ /* 2 bytes: length of section, then [length] bytes: unknown purpose */
+ if (hdr->headers & MSKWAJ_HDR_HASUNKNOWN2) {
+ if (sys->read(fh, &buf[0], 2) != 2) return MSPACK_ERR_READ;
+ i = EndGetI16(&buf[0]);
+ if (sys->seek(fh, (off_t)i, MSPACK_SYS_SEEK_CUR)) return MSPACK_ERR_SEEK;
+ }
+
+ /* filename and extension */
+ if (hdr->headers & (MSKWAJ_HDR_HASFILENAME | MSKWAJ_HDR_HASFILEEXT)) {
+ off_t pos = sys->tell(fh);
+ char *fn = (char *) sys->alloc(sys, (size_t) 13);
+
+ /* allocate memory for maximum length filename */
+ if (! fn) return MSPACK_ERR_NOMEMORY;
+ hdr->filename = fn;
+
+ /* copy filename if present */
+ if (hdr->headers & MSKWAJ_HDR_HASFILENAME) {
+ if (sys->read(fh, &buf[0], 9) != 9) return MSPACK_ERR_READ;
+ for (i = 0; i < 9; i++, fn++) if (!(*fn = buf[i])) break;
+ pos += (i < 9) ? i+1 : 9;
+ if (sys->seek(fh, pos, MSPACK_SYS_SEEK_START))
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* copy extension if present */
+ if (hdr->headers & MSKWAJ_HDR_HASFILEEXT) {
+ *fn++ = '.';
+ if (sys->read(fh, &buf[0], 4) != 4) return MSPACK_ERR_READ;
+ for (i = 0; i < 4; i++, fn++) if (!(*fn = buf[i])) break;
+ pos += (i < 4) ? i+1 : 4;
+ if (sys->seek(fh, pos, MSPACK_SYS_SEEK_START))
+ return MSPACK_ERR_SEEK;
+ }
+ *fn = '\0';
+ }
+
+ /* 2 bytes: extra text length then [length] bytes of extra text data */
+ if (hdr->headers & MSKWAJ_HDR_HASEXTRATEXT) {
+ if (sys->read(fh, &buf[0], 2) != 2) return MSPACK_ERR_READ;
+ i = EndGetI16(&buf[0]);
+ hdr->extra = (char *) sys->alloc(sys, (size_t)i+1);
+ if (! hdr->extra) return MSPACK_ERR_NOMEMORY;
+ if (sys->read(fh, hdr->extra, i) != i) return MSPACK_ERR_READ;
+ hdr->extra[i] = '\0';
+ hdr->extra_length = i;
+ }
+ return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * KWAJD_EXTRACT
+ ***************************************
+ * decompresses a KWAJ file
+ */
+static int kwajd_extract(struct mskwaj_decompressor *base,
+ struct mskwajd_header *hdr, const char *filename)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ struct mspack_system *sys;
+ struct mspack_file *fh, *outfh;
+
+ if (!self) return MSPACK_ERR_ARGS;
+ if (!hdr) return self->error = MSPACK_ERR_ARGS;
+
+ sys = self->system;
+ fh = ((struct mskwajd_header_p *) hdr)->fh;
+
+ /* seek to the compressed data */
+ if (sys->seek(fh, hdr->data_offset, MSPACK_SYS_SEEK_START)) {
+ return self->error = MSPACK_ERR_SEEK;
+ }
+
+ /* open file for output */
+ if (!(outfh = sys->open(sys, filename, MSPACK_SYS_OPEN_WRITE))) {
+ return self->error = MSPACK_ERR_OPEN;
+ }
+
+ self->error = MSPACK_ERR_OK;
+
+ /* decompress based on format */
+ if (hdr->comp_type == MSKWAJ_COMP_NONE ||
+ hdr->comp_type == MSKWAJ_COMP_XOR)
+ {
+ /* NONE is a straight copy. XOR is a copy xored with 0xFF */
+ unsigned char *buf = (unsigned char *) sys->alloc(sys, (size_t) KWAJ_INPUT_SIZE);
+ if (buf) {
+ int read, i;
+ while ((read = sys->read(fh, buf, KWAJ_INPUT_SIZE)) > 0) {
+ if (hdr->comp_type == MSKWAJ_COMP_XOR) {
+ for (i = 0; i < read; i++) buf[i] ^= 0xFF;
+ }
+ if (sys->write(outfh, buf, read) != read) {
+ self->error = MSPACK_ERR_WRITE;
+ break;
+ }
+ }
+ if (read < 0) self->error = MSPACK_ERR_READ;
+ sys->free(buf);
+ }
+ else {
+ self->error = MSPACK_ERR_NOMEMORY;
+ }
+ }
+ else if (hdr->comp_type == MSKWAJ_COMP_SZDD) {
+ self->error = lzss_decompress(sys, fh, outfh, KWAJ_INPUT_SIZE,
+ LZSS_MODE_EXPAND);
+ }
+ else if (hdr->comp_type == MSKWAJ_COMP_LZH) {
+ struct kwajd_stream *lzh = lzh_init(sys, fh, outfh);
+ self->error = (lzh) ? lzh_decompress(lzh) : MSPACK_ERR_NOMEMORY;
+ lzh_free(lzh);
+ }
+ else {
+ self->error = MSPACK_ERR_DATAFORMAT;
+ }
+
+ /* close output file */
+ sys->close(outfh);
+
+ return self->error;
+}
+
+/***************************************
+ * KWAJD_DECOMPRESS
+ ***************************************
+ * unpacks directly from input to output
+ */
+static int kwajd_decompress(struct mskwaj_decompressor *base,
+ const char *input, const char *output)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ struct mskwajd_header *hdr;
+ int error;
+
+ if (!self) return MSPACK_ERR_ARGS;
+
+ if (!(hdr = kwajd_open(base, input))) return self->error;
+ error = kwajd_extract(base, hdr, output);
+ kwajd_close(base, hdr);
+ return self->error = error;
+}
+
+/***************************************
+ * KWAJD_ERROR
+ ***************************************
+ * returns the last error that occurred
+ */
+static int kwajd_error(struct mskwaj_decompressor *base)
+{
+ struct mskwaj_decompressor_p *self = (struct mskwaj_decompressor_p *) base;
+ return (self) ? self->error : MSPACK_ERR_ARGS;
+}
+
+/***************************************
+ * LZH_INIT, LZH_DECOMPRESS, LZH_FREE
+ ***************************************
+ * unpacks KWAJ method 3 files
+ */
+
+/* import bit-reading macros and code */
+#define BITS_TYPE struct kwajd_stream
+#define BITS_VAR lzh
+#define BITS_ORDER_MSB
+#define BITS_NO_READ_INPUT
+#define READ_BYTES do { \
+ if (i_ptr >= i_end) { \
+ if ((err = lzh_read_input(lzh))) return err; \
+ i_ptr = lzh->i_ptr; \
+ i_end = lzh->i_end; \
+ } \
+ INJECT_BITS(*i_ptr++, 8); \
+} while (0)
+#include <readbits.h>
+
+/* import huffman-reading macros and code */
+#define TABLEBITS(tbl) KWAJ_TABLEBITS
+#define MAXSYMBOLS(tbl) KWAJ_##tbl##_SYMS
+#define HUFF_TABLE(tbl,idx) lzh->tbl##_table[idx]
+#define HUFF_LEN(tbl,idx) lzh->tbl##_len[idx]
+#define HUFF_ERROR return MSPACK_ERR_DATAFORMAT
+#include <readhuff.h>
+
+/* In the KWAJ LZH format, there is no special 'eof' marker, it just
+ * ends. Depending on how many bits are left in the final byte when
+ * the stream ends, that might be enough to start another literal or
+ * match. The only easy way to detect that we've come to an end is to
+ * guard all bit-reading. We allow fake bits to be read once we reach
+ * the end of the stream, but we check if we then consumed any of
+ * those fake bits, after doing the READ_BITS / READ_HUFFSYM. This
+ * isn't how the default readbits.h read_input() works (it simply lets
+ * 2 fake bytes in then stops), so we implement our own.
+ */
+#define READ_BITS_SAFE(val, n) do { \
+ READ_BITS(val, n); \
+ if (lzh->input_end && bits_left < lzh->input_end) \
+ return MSPACK_ERR_OK; \
+} while (0)
+
+#define READ_HUFFSYM_SAFE(tbl, val) do { \
+ READ_HUFFSYM(tbl, val); \
+ if (lzh->input_end && bits_left < lzh->input_end) \
+ return MSPACK_ERR_OK; \
+} while (0)
+
+#define BUILD_TREE(tbl, type) \
+ STORE_BITS; \
+ err = lzh_read_lens(lzh, type, MAXSYMBOLS(tbl), \
+ &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0)); \
+ if (err) return err; \
+ RESTORE_BITS; \
+ if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl), \
+ &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0))) \
+ return MSPACK_ERR_DATAFORMAT;
+
+#define WRITE_BYTE do { \
+ if (lzh->sys->write(lzh->output, &lzh->window[pos], 1) != 1) \
+ return MSPACK_ERR_WRITE; \
+} while (0)
+
+static struct kwajd_stream *lzh_init(struct mspack_system *sys,
+ struct mspack_file *in, struct mspack_file *out)
+{
+ struct kwajd_stream *lzh;
+
+ if (!sys || !in || !out) return NULL;
+ if (!(lzh = (struct kwajd_stream *) sys->alloc(sys, sizeof(struct kwajd_stream)))) return NULL;
+
+ lzh->sys = sys;
+ lzh->input = in;
+ lzh->output = out;
+ return lzh;
+}
+
+static int lzh_decompress(struct kwajd_stream *lzh)
+{
+ register unsigned int bit_buffer;
+ register int bits_left, i;
+ register unsigned short sym;
+ unsigned char *i_ptr, *i_end, lit_run = 0;
+ int j, pos = 0, len, offset, err;
+ unsigned int types[6];
+
+ /* reset global state */
+ INIT_BITS;
+ RESTORE_BITS;
+ memset(&lzh->window[0], LZSS_WINDOW_FILL, (size_t) LZSS_WINDOW_SIZE);
+
+ /* read 6 encoding types (for byte alignment) but only 5 are needed */
+ for (i = 0; i < 6; i++) READ_BITS_SAFE(types[i], 4);
+
+ /* read huffman table symbol lengths and build huffman trees */
+ BUILD_TREE(MATCHLEN1, types[0]);
+ BUILD_TREE(MATCHLEN2, types[1]);
+ BUILD_TREE(LITLEN, types[2]);
+ BUILD_TREE(OFFSET, types[3]);
+ BUILD_TREE(LITERAL, types[4]);
+
+ while (!lzh->input_end) {
+ if (lit_run) READ_HUFFSYM_SAFE(MATCHLEN2, len);
+ else READ_HUFFSYM_SAFE(MATCHLEN1, len);
+
+ if (len > 0) {
+ len += 2;
+ lit_run = 0; /* not the end of a literal run */
+ READ_HUFFSYM_SAFE(OFFSET, j); offset = j << 6;
+ READ_BITS_SAFE(j, 6); offset |= j;
+
+ /* copy match as output and into the ring buffer */
+ while (len-- > 0) {
+ lzh->window[pos] = lzh->window[(pos+4096-offset) & 4095];
+ WRITE_BYTE;
+ pos++; pos &= 4095;
+ }
+ }
+ else {
+ READ_HUFFSYM_SAFE(LITLEN, len); len++;
+ lit_run = (len == 32) ? 0 : 1; /* end of a literal run? */
+ while (len-- > 0) {
+ READ_HUFFSYM_SAFE(LITERAL, j);
+ /* copy as output and into the ring buffer */
+ lzh->window[pos] = j;
+ WRITE_BYTE;
+ pos++; pos &= 4095;
+ }
+ }
+ }
+ return MSPACK_ERR_OK;
+}
+
+static void lzh_free(struct kwajd_stream *lzh)
+{
+ struct mspack_system *sys;
+ if (!lzh || !lzh->sys) return;
+ sys = lzh->sys;
+ sys->free(lzh);
+}
+
+static int lzh_read_lens(struct kwajd_stream *lzh,
+ unsigned int type, unsigned int numsyms,
+ unsigned char *lens, unsigned short *table)
+{
+ register unsigned int bit_buffer;
+ register int bits_left;
+ unsigned char *i_ptr, *i_end;
+ unsigned int i, c, sel;
+ int err;
+
+ RESTORE_BITS;
+ switch (type) {
+ case 0:
+ i = numsyms; c = (i==16)?4: (i==32)?5: (i==64)?6: (i==256)?8 :0;
+ for (i = 0; i < numsyms; i++) lens[i] = c;
+ break;
+
+ case 1:
+ READ_BITS_SAFE(c, 4); lens[0] = c;
+ for (i = 1; i < numsyms; i++) {
+ READ_BITS_SAFE(sel, 1); if (sel == 0) lens[i] = c;
+ else { READ_BITS_SAFE(sel, 1); if (sel == 0) lens[i] = ++c;
+ else { READ_BITS_SAFE(c, 4); lens[i] = c; }}
+ }
+ break;
+
+ case 2:
+ READ_BITS_SAFE(c, 4); lens[0] = c;
+ for (i = 1; i < numsyms; i++) {
+ READ_BITS_SAFE(sel, 2);
+ if (sel == 3) READ_BITS_SAFE(c, 4); else c += (char) sel-1;
+ lens[i] = c;
+ }
+ break;
+
+ case 3:
+ for (i = 0; i < numsyms; i++) {
+ READ_BITS_SAFE(c, 4); lens[i] = c;
+ }
+ break;
+ }
+ STORE_BITS;
+ return MSPACK_ERR_OK;
+}
+
+static int lzh_read_input(struct kwajd_stream *lzh) {
+ int read;
+ if (lzh->input_end) {
+ lzh->input_end += 8;
+ lzh->inbuf[0] = 0;
+ read = 1;
+ }
+ else {
+ read = lzh->sys->read(lzh->input, &lzh->inbuf[0], KWAJ_INPUT_SIZE);
+ if (read < 0) return MSPACK_ERR_READ;
+ if (read == 0) {
+ lzh->input_end = 8;
+ lzh->inbuf[0] = 0;
+ read = 1;
+ }
+ }
+
+ /* update i_ptr and i_end */
+ lzh->i_ptr = &lzh->inbuf[0];
+ lzh->i_end = &lzh->inbuf[read];
+ return MSPACK_ERR_OK;
+}
diff --git a/rbutil/rbutilqt/mspack/lit.h b/rbutil/rbutilqt/mspack/lit.h
new file mode 100644
index 0000000000..79ba44d877
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lit.h
@@ -0,0 +1,35 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_LIT_H
+#define MSPACK_LIT_H 1
+
+#include <lzx.h>
+#include <des.h>
+#include <sha.h>
+
+/* generic LIT definitions */
+
+/* LIT compression definitions */
+
+struct mslit_compressor_p {
+ struct mslit_compressor base;
+ struct mspack_system *system;
+ /* todo */
+};
+
+/* LIT decompression definitions */
+
+struct mslit_decompressor_p {
+ struct mslit_decompressor base;
+ struct mspack_system *system;
+ /* todo */
+};
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/litc.c b/rbutil/rbutilqt/mspack/litc.c
new file mode 100644
index 0000000000..a8a709af07
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/litc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* LIT compression implementation */
+
+#include <system.h>
+#include <lit.h>
+
+struct mslit_compressor *
+ mspack_create_lit_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_lit_compressor(struct mslit_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/litd.c b/rbutil/rbutilqt/mspack/litd.c
new file mode 100644
index 0000000000..6e0dc9af27
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/litd.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* LIT decompression implementation */
+
+#include <system.h>
+#include <lit.h>
+
+struct mslit_decompressor *
+ mspack_create_lit_decompressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_lit_decompressor(struct mslit_decompressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/lzss.h b/rbutil/rbutilqt/mspack/lzss.h
new file mode 100644
index 0000000000..55e761b5bf
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lzss.h
@@ -0,0 +1,66 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_LZSS_H
+#define MSPACK_LZSS_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* LZSS compression / decompression definitions */
+
+#define LZSS_WINDOW_SIZE (4096)
+#define LZSS_WINDOW_FILL (0x20)
+
+#define LZSS_MODE_EXPAND (0)
+#define LZSS_MODE_MSHELP (1)
+#define LZSS_MODE_QBASIC (2)
+
+/**
+ * Decompresses an LZSS stream.
+ *
+ * Input bytes will be read in as necessary using the system->read()
+ * function with the input file handle given. This will continue until
+ * system->read() returns 0 bytes, or an error. Errors will be passed
+ * out of the function as MSPACK_ERR_READ errors. Input streams should
+ * convey an "end of input stream" by refusing to supply all the bytes
+ * that LZSS asks for when they reach the end of the stream, rather
+ * than return an error code.
+ *
+ * Output bytes will be passed to the system->write() function, using
+ * the output file handle given. More than one call may be made to
+ * system->write().
+ *
+ * As EXPAND.EXE (SZDD/KWAJ), Microsoft Help and QBasic have slightly
+ * different encodings for the control byte and matches, a "mode"
+ * parameter is allowed, to choose the encoding.
+ *
+ * @param system an mspack_system structure used to read from
+ * the input stream and write to the output
+ * stream, also to allocate and free memory.
+ * @param input an input stream with the LZSS data.
+ * @param output an output stream to write the decoded data to.
+ * @param input_buffer_size the number of bytes to use as an input
+ * bitstream buffer.
+ * @param mode one of #LZSS_MODE_EXPAND, #LZSS_MODE_MSHELP or
+ * #LZSS_MODE_QBASIC
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+extern int lzss_decompress(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int input_buffer_size,
+ int mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/lzssd.c b/rbutil/rbutilqt/mspack/lzssd.c
new file mode 100644
index 0000000000..df294bc132
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lzssd.c
@@ -0,0 +1,93 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * LZSS is a derivative of LZ77 and was created by James Storer and
+ * Thomas Szymanski in 1982. Haruhiko Okumura wrote a very popular C
+ * implementation.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#include <system.h>
+#include <lzss.h>
+
+#define ENSURE_BYTES do { \
+ if (i_ptr >= i_end) { \
+ read = system->read(input, &inbuf[0], \
+ input_buffer_size); \
+ if (read <= 0) { \
+ system->free(window); \
+ return (read < 0) ? MSPACK_ERR_READ \
+ : MSPACK_ERR_OK; \
+ } \
+ i_ptr = &inbuf[0]; i_end = &inbuf[read]; \
+ } \
+} while (0)
+
+#define WRITE_BYTE do { \
+ if (system->write(output, &window[pos], 1) != 1) { \
+ system->free(window); \
+ return MSPACK_ERR_WRITE; \
+ } \
+} while (0)
+
+int lzss_decompress(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int input_buffer_size,
+ int mode)
+{
+ unsigned char *window, *inbuf, *i_ptr, *i_end;
+ unsigned int pos, i, c, invert, mpos, len;
+ int read;
+
+ /* check parameters */
+ if (!system || input_buffer_size < 1 || (mode != LZSS_MODE_EXPAND &&
+ mode != LZSS_MODE_MSHELP && mode != LZSS_MODE_QBASIC))
+ {
+ return MSPACK_ERR_ARGS;
+ }
+
+ /* allocate memory */
+ window = (unsigned char *) system->alloc(system, LZSS_WINDOW_SIZE + input_buffer_size);
+ if (!window) return MSPACK_ERR_NOMEMORY;
+
+ /* initialise decompression */
+ inbuf = &window[LZSS_WINDOW_SIZE];
+ memset(window, LZSS_WINDOW_FILL, (size_t) LZSS_WINDOW_SIZE);
+ pos = LZSS_WINDOW_SIZE - ((mode == LZSS_MODE_QBASIC) ? 18 : 16);
+ invert = (mode == LZSS_MODE_MSHELP) ? ~0 : 0;
+ i_ptr = i_end = &inbuf[0];
+
+ /* loop forever; exit condition is in ENSURE_BYTES macro */
+ for (;;) {
+ ENSURE_BYTES; c = *i_ptr++ ^ invert;
+ for (i = 0x01; i & 0xFF; i <<= 1) {
+ if (c & i) {
+ /* literal */
+ ENSURE_BYTES; window[pos] = *i_ptr++;
+ WRITE_BYTE;
+ pos++; pos &= LZSS_WINDOW_SIZE - 1;
+ }
+ else {
+ /* match */
+ ENSURE_BYTES; mpos = *i_ptr++;
+ ENSURE_BYTES; mpos |= (*i_ptr & 0xF0) << 4;
+ len = (*i_ptr++ & 0x0F) + 3;
+ while (len--) {
+ window[pos] = window[mpos];
+ WRITE_BYTE;
+ pos++; pos &= LZSS_WINDOW_SIZE - 1;
+ mpos++; mpos &= LZSS_WINDOW_SIZE - 1;
+ }
+ }
+ }
+ }
+
+ /* not reached */
+ system->free(window);
+ return MSPACK_ERR_OK;
+}
diff --git a/rbutil/rbutilqt/mspack/lzx.h b/rbutil/rbutilqt/mspack/lzx.h
new file mode 100644
index 0000000000..fc69928c96
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lzx.h
@@ -0,0 +1,194 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
+ * by Microsoft Corporation.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_LZX_H
+#define MSPACK_LZX_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* LZX compression / decompression definitions */
+
+/* some constants defined by the LZX specification */
+#define LZX_MIN_MATCH (2)
+#define LZX_MAX_MATCH (257)
+#define LZX_NUM_CHARS (256)
+#define LZX_BLOCKTYPE_INVALID (0) /* also blocktypes 4-7 invalid */
+#define LZX_BLOCKTYPE_VERBATIM (1)
+#define LZX_BLOCKTYPE_ALIGNED (2)
+#define LZX_BLOCKTYPE_UNCOMPRESSED (3)
+#define LZX_PRETREE_NUM_ELEMENTS (20)
+#define LZX_ALIGNED_NUM_ELEMENTS (8) /* aligned offset tree #elements */
+#define LZX_NUM_PRIMARY_LENGTHS (7) /* this one missing from spec! */
+#define LZX_NUM_SECONDARY_LENGTHS (249) /* length tree #elements */
+
+/* LZX huffman defines: tweak tablebits as desired */
+#define LZX_PRETREE_MAXSYMBOLS (LZX_PRETREE_NUM_ELEMENTS)
+#define LZX_PRETREE_TABLEBITS (6)
+#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8)
+#define LZX_MAINTREE_TABLEBITS (12)
+#define LZX_LENGTH_MAXSYMBOLS (LZX_NUM_SECONDARY_LENGTHS+1)
+#define LZX_LENGTH_TABLEBITS (12)
+#define LZX_ALIGNED_MAXSYMBOLS (LZX_ALIGNED_NUM_ELEMENTS)
+#define LZX_ALIGNED_TABLEBITS (7)
+#define LZX_LENTABLE_SAFETY (64) /* table decoding overruns are allowed */
+
+#define LZX_FRAME_SIZE (32768) /* the size of a frame in LZX */
+
+struct lzxd_stream {
+ struct mspack_system *sys; /* I/O routines */
+ struct mspack_file *input; /* input file handle */
+ struct mspack_file *output; /* output file handle */
+
+ off_t offset; /* number of bytes actually output */
+ off_t length; /* overall decompressed length of stream */
+
+ unsigned char *window; /* decoding window */
+ unsigned int window_size; /* window size */
+ unsigned int window_posn; /* decompression offset within window */
+ unsigned int frame_posn; /* current frame offset within in window */
+ unsigned int frame; /* the number of 32kb frames processed */
+ unsigned int reset_interval; /* which frame do we reset the compressor? */
+
+ unsigned int R0, R1, R2; /* for the LRU offset system */
+ unsigned int block_length; /* uncompressed length of this LZX block */
+ unsigned int block_remaining; /* uncompressed bytes still left to decode */
+
+ signed int intel_filesize; /* magic header value used for transform */
+ signed int intel_curpos; /* current offset in transform space */
+
+ unsigned char intel_started; /* has intel E8 decoding started? */
+ unsigned char block_type; /* type of the current block */
+ unsigned char header_read; /* have we started decoding at all yet? */
+ unsigned char posn_slots; /* how many posn slots in stream? */
+ unsigned char input_end; /* have we reached the end of input? */
+
+ int error;
+
+ /* I/O buffering */
+ unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end;
+ unsigned int bit_buffer, bits_left, inbuf_size;
+
+ /* huffman code lengths */
+ unsigned char PRETREE_len [LZX_PRETREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+ unsigned char MAINTREE_len [LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+ unsigned char LENGTH_len [LZX_LENGTH_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+ unsigned char ALIGNED_len [LZX_ALIGNED_MAXSYMBOLS + LZX_LENTABLE_SAFETY];
+
+ /* huffman decoding tables */
+ unsigned short PRETREE_table [(1 << LZX_PRETREE_TABLEBITS) +
+ (LZX_PRETREE_MAXSYMBOLS * 2)];
+ unsigned short MAINTREE_table[(1 << LZX_MAINTREE_TABLEBITS) +
+ (LZX_MAINTREE_MAXSYMBOLS * 2)];
+ unsigned short LENGTH_table [(1 << LZX_LENGTH_TABLEBITS) +
+ (LZX_LENGTH_MAXSYMBOLS * 2)];
+ unsigned short ALIGNED_table [(1 << LZX_ALIGNED_TABLEBITS) +
+ (LZX_ALIGNED_MAXSYMBOLS * 2)];
+ unsigned char LENGTH_empty;
+
+ /* this is used purely for doing the intel E8 transform */
+ unsigned char e8_buf[LZX_FRAME_SIZE];
+};
+
+/**
+ * Allocates and initialises LZX decompression state for decoding an LZX
+ * stream.
+ *
+ * This routine uses system->alloc() to allocate memory. If memory
+ * allocation fails, or the parameters to this function are invalid,
+ * NULL is returned.
+ *
+ * @param system an mspack_system structure used to read from
+ * the input stream and write to the output
+ * stream, also to allocate and free memory.
+ * @param input an input stream with the LZX data.
+ * @param output an output stream to write the decoded data to.
+ * @param window_bits the size of the decoding window, which must be
+ * between 15 and 21 inclusive.
+ * @param reset_interval the interval at which the LZX bitstream is
+ * reset, in multiples of LZX frames (32678
+ * bytes), e.g. a value of 2 indicates the input
+ * stream resets after every 65536 output bytes.
+ * A value of 0 indicates that the bistream never
+ * resets, such as in CAB LZX streams.
+ * @param input_buffer_size the number of bytes to use as an input
+ * bitstream buffer.
+ * @param output_length the length in bytes of the entirely
+ * decompressed output stream, if known in
+ * advance. It is used to correctly perform the
+ * Intel E8 transformation, which must stop 6
+ * bytes before the very end of the
+ * decompressed stream. It is not otherwise used
+ * or adhered to. If the full decompressed
+ * length is known in advance, set it here.
+ * If it is NOT known, use the value 0, and call
+ * lzxd_set_output_length() once it is
+ * known. If never set, 4 of the final 6 bytes
+ * of the output stream may be incorrect.
+ * @return a pointer to an initialised lzxd_stream structure, or NULL if
+ * there was not enough memory or parameters to the function were wrong.
+ */
+extern struct lzxd_stream *lzxd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int window_bits,
+ int reset_interval,
+ int input_buffer_size,
+ off_t output_length);
+
+/* see description of output_length in lzxd_init() */
+extern void lzxd_set_output_length(struct lzxd_stream *lzx,
+ off_t output_length);
+
+/**
+ * Decompresses entire or partial LZX streams.
+ *
+ * The number of bytes of data that should be decompressed is given as the
+ * out_bytes parameter. If more bytes are decoded than are needed, they
+ * will be kept over for a later invocation.
+ *
+ * The output bytes will be passed to the system->write() function given in
+ * lzxd_init(), using the output file handle given in lzxd_init(). More than
+ * one call may be made to system->write().
+
+ * Input bytes will be read in as necessary using the system->read()
+ * function given in lzxd_init(), using the input file handle given in
+ * lzxd_init(). This will continue until system->read() returns 0 bytes,
+ * or an error. Errors will be passed out of the function as
+ * MSPACK_ERR_READ errors. Input streams should convey an "end of input
+ * stream" by refusing to supply all the bytes that LZX asks for when they
+ * reach the end of the stream, rather than return an error code.
+ *
+ * If any error code other than MSPACK_ERR_OK is returned, the stream
+ * should be considered unusable and lzxd_decompress() should not be
+ * called again on this stream.
+ *
+ * @param lzx LZX decompression state, as allocated by lzxd_init().
+ * @param out_bytes the number of bytes of data to decompress.
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+extern int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes);
+
+/**
+ * Frees all state associated with an LZX data stream. This will call
+ * system->free() using the system pointer given in lzxd_init().
+ *
+ * @param lzx LZX decompression state to free.
+ */
+void lzxd_free(struct lzxd_stream *lzx);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/lzxc.c b/rbutil/rbutilqt/mspack/lzxc.c
new file mode 100644
index 0000000000..1207a0d747
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lzxc.c
@@ -0,0 +1,18 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
+ * by Microsoft Corporation.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* LZX compression implementation */
+
+#include <system.h>
+#include <lzx.h>
+
+/* todo */
diff --git a/rbutil/rbutilqt/mspack/lzxd.c b/rbutil/rbutilqt/mspack/lzxd.c
new file mode 100644
index 0000000000..cebc4c23d3
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/lzxd.c
@@ -0,0 +1,738 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
+ * by Microsoft Corporation.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* LZX decompression implementation */
+
+#include <system.h>
+#include <lzx.h>
+
+/* Microsoft's LZX document (in cab-sdk.exe) and their implementation
+ * of the com.ms.util.cab Java package do not concur.
+ *
+ * In the LZX document, there is a table showing the correlation between
+ * window size and the number of position slots. It states that the 1MB
+ * window = 40 slots and the 2MB window = 42 slots. In the implementation,
+ * 1MB = 42 slots, 2MB = 50 slots. The actual calculation is 'find the
+ * first slot whose position base is equal to or more than the required
+ * window size'. This would explain why other tables in the document refer
+ * to 50 slots rather than 42.
+ *
+ * The constant NUM_PRIMARY_LENGTHS used in the decompression pseudocode
+ * is not defined in the specification.
+ *
+ * The LZX document does not state the uncompressed block has an
+ * uncompressed length field. Where does this length field come from, so
+ * we can know how large the block is? The implementation has it as the 24
+ * bits following after the 3 blocktype bits, before the alignment
+ * padding.
+ *
+ * The LZX document states that aligned offset blocks have their aligned
+ * offset huffman tree AFTER the main and length trees. The implementation
+ * suggests that the aligned offset tree is BEFORE the main and length
+ * trees.
+ *
+ * The LZX document decoding algorithm states that, in an aligned offset
+ * block, if an extra_bits value is 1, 2 or 3, then that number of bits
+ * should be read and the result added to the match offset. This is
+ * correct for 1 and 2, but not 3, where just a huffman symbol (using the
+ * aligned tree) should be read.
+ *
+ * Regarding the E8 preprocessing, the LZX document states 'No translation
+ * may be performed on the last 6 bytes of the input block'. This is
+ * correct. However, the pseudocode provided checks for the *E8 leader*
+ * up to the last 6 bytes. If the leader appears between -10 and -7 bytes
+ * from the end, this would cause the next four bytes to be modified, at
+ * least one of which would be in the last 6 bytes, which is not allowed
+ * according to the spec.
+ *
+ * The specification states that the huffman trees must always contain at
+ * least one element. However, many CAB files contain blocks where the
+ * length tree is completely empty (because there are no matches), and
+ * this is expected to succeed.
+ *
+ * The errors in LZX documentation appear have been corrected in the
+ * new documentation for the LZX DELTA format.
+ *
+ * http://msdn.microsoft.com/en-us/library/cc483133.aspx
+ *
+ * However, this is a different format, an extension of regular LZX.
+ * I have noticed the following differences, there may be more:
+ *
+ * The maximum window size has increased from 2MB to 32MB. This also
+ * increases the maximum number of position slots, etc.
+ *
+ * The format now allows for "reference data", supplied by the caller.
+ * If match offsets go further back than the number of bytes
+ * decompressed so far, that is them accessing the reference data.
+ */
+
+/* import bit-reading macros and code */
+#define BITS_TYPE struct lzxd_stream
+#define BITS_VAR lzx
+#define BITS_ORDER_MSB
+#define READ_BYTES do { \
+ unsigned char b0, b1; \
+ READ_IF_NEEDED; b0 = *i_ptr++; \
+ READ_IF_NEEDED; b1 = *i_ptr++; \
+ INJECT_BITS((b1 << 8) | b0, 16); \
+} while (0)
+#include <readbits.h>
+
+/* import huffman-reading macros and code */
+#define TABLEBITS(tbl) LZX_##tbl##_TABLEBITS
+#define MAXSYMBOLS(tbl) LZX_##tbl##_MAXSYMBOLS
+#define HUFF_TABLE(tbl,idx) lzx->tbl##_table[idx]
+#define HUFF_LEN(tbl,idx) lzx->tbl##_len[idx]
+#define HUFF_ERROR return lzx->error = MSPACK_ERR_DECRUNCH
+#include <readhuff.h>
+
+/* BUILD_TABLE(tbl) builds a huffman lookup table from code lengths */
+#define BUILD_TABLE(tbl) \
+ if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl), \
+ &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0))) \
+ { \
+ D(("failed to build %s table", #tbl)) \
+ return lzx->error = MSPACK_ERR_DECRUNCH; \
+ }
+
+#define BUILD_TABLE_MAYBE_EMPTY(tbl) do { \
+ lzx->tbl##_empty = 0; \
+ if (make_decode_table(MAXSYMBOLS(tbl), TABLEBITS(tbl), \
+ &HUFF_LEN(tbl,0), &HUFF_TABLE(tbl,0))) \
+ { \
+ for (i = 0; i < MAXSYMBOLS(tbl); i++) { \
+ if (HUFF_LEN(tbl, i) > 0) { \
+ D(("failed to build %s table", #tbl)) \
+ return lzx->error = MSPACK_ERR_DECRUNCH; \
+ } \
+ } \
+ /* empty tree - allow it, but don't decode symbols with it */ \
+ lzx->tbl##_empty = 1; \
+ } \
+} while (0)
+
+/* READ_LENGTHS(tablename, first, last) reads in code lengths for symbols
+ * first to last in the given table. The code lengths are stored in their
+ * own special LZX way.
+ */
+#define READ_LENGTHS(tbl, first, last) do { \
+ STORE_BITS; \
+ if (lzxd_read_lens(lzx, &HUFF_LEN(tbl, 0), (first), \
+ (unsigned int)(last))) return lzx->error; \
+ RESTORE_BITS; \
+} while (0)
+
+static int lzxd_read_lens(struct lzxd_stream *lzx, unsigned char *lens,
+ unsigned int first, unsigned int last)
+{
+ /* bit buffer and huffman symbol decode variables */
+ register unsigned int bit_buffer;
+ register int bits_left, i;
+ register unsigned short sym;
+ unsigned char *i_ptr, *i_end;
+
+ unsigned int x, y;
+ int z;
+
+ RESTORE_BITS;
+
+ /* read lengths for pretree (20 symbols, lengths stored in fixed 4 bits) */
+ for (x = 0; x < 20; x++) {
+ READ_BITS(y, 4);
+ lzx->PRETREE_len[x] = y;
+ }
+ BUILD_TABLE(PRETREE);
+
+ for (x = first; x < last; ) {
+ READ_HUFFSYM(PRETREE, z);
+ if (z == 17) {
+ /* code = 17, run of ([read 4 bits]+4) zeros */
+ READ_BITS(y, 4); y += 4;
+ while (y--) lens[x++] = 0;
+ }
+ else if (z == 18) {
+ /* code = 18, run of ([read 5 bits]+20) zeros */
+ READ_BITS(y, 5); y += 20;
+ while (y--) lens[x++] = 0;
+ }
+ else if (z == 19) {
+ /* code = 19, run of ([read 1 bit]+4) [read huffman symbol] */
+ READ_BITS(y, 1); y += 4;
+ READ_HUFFSYM(PRETREE, z);
+ z = lens[x] - z; if (z < 0) z += 17;
+ while (y--) lens[x++] = z;
+ }
+ else {
+ /* code = 0 to 16, delta current length entry */
+ z = lens[x] - z; if (z < 0) z += 17;
+ lens[x++] = z;
+ }
+ }
+
+ STORE_BITS;
+
+ return MSPACK_ERR_OK;
+}
+
+/* LZX static data tables:
+ *
+ * LZX uses 'position slots' to represent match offsets. For every match,
+ * a small 'position slot' number and a small offset from that slot are
+ * encoded instead of one large offset.
+ *
+ * position_base[] is an index to the position slot bases
+ *
+ * extra_bits[] states how many bits of offset-from-base data is needed.
+ *
+ * They are generated like so:
+ * for (i = 0; i < 4; i++) extra_bits[i] = 0;
+ * for (i = 4, j = 0; i < 36; i+=2) extra_bits[i] = extra_bits[i+1] = j++;
+ * for (i = 36; i < 51; i++) extra_bits[i] = 17;
+ * for (i = 0, j = 0; i < 51; j += 1 << extra_bits[i++]) position_base[i] = j;
+ */
+static const unsigned int position_base[51] = {
+ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256,
+ 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288,
+ 16384, 24576, 32768, 49152, 65536, 98304, 131072, 196608, 262144,
+ 393216, 524288, 655360, 786432, 917504, 1048576, 1179648, 1310720,
+ 1441792, 1572864, 1703936, 1835008, 1966080, 2097152
+};
+static const unsigned char extra_bits[51] = {
+ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
+ 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
+ 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
+};
+
+static void lzxd_reset_state(struct lzxd_stream *lzx) {
+ int i;
+
+ lzx->R0 = 1;
+ lzx->R1 = 1;
+ lzx->R2 = 1;
+ lzx->header_read = 0;
+ lzx->block_remaining = 0;
+ lzx->block_type = LZX_BLOCKTYPE_INVALID;
+
+ /* initialise tables to 0 (because deltas will be applied to them) */
+ for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) lzx->MAINTREE_len[i] = 0;
+ for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++) lzx->LENGTH_len[i] = 0;
+}
+
+/*-------- main LZX code --------*/
+
+struct lzxd_stream *lzxd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int window_bits,
+ int reset_interval,
+ int input_buffer_size,
+ off_t output_length)
+{
+ unsigned int window_size = 1 << window_bits;
+ struct lzxd_stream *lzx;
+
+ if (!system) return NULL;
+
+ /* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */
+ if (window_bits < 15 || window_bits > 21) return NULL;
+
+ input_buffer_size = (input_buffer_size + 1) & -2;
+ if (!input_buffer_size) return NULL;
+
+ /* allocate decompression state */
+ if (!(lzx = (struct lzxd_stream *) system->alloc(system, sizeof(struct lzxd_stream)))) {
+ return NULL;
+ }
+
+ /* allocate decompression window and input buffer */
+ lzx->window = (unsigned char *) system->alloc(system, (size_t) window_size);
+ lzx->inbuf = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
+ if (!lzx->window || !lzx->inbuf) {
+ system->free(lzx->window);
+ system->free(lzx->inbuf);
+ system->free(lzx);
+ return NULL;
+ }
+
+ /* initialise decompression state */
+ lzx->sys = system;
+ lzx->input = input;
+ lzx->output = output;
+ lzx->offset = 0;
+ lzx->length = output_length;
+
+ lzx->inbuf_size = input_buffer_size;
+ lzx->window_size = 1 << window_bits;
+ lzx->window_posn = 0;
+ lzx->frame_posn = 0;
+ lzx->frame = 0;
+ lzx->reset_interval = reset_interval;
+ lzx->intel_filesize = 0;
+ lzx->intel_curpos = 0;
+ lzx->intel_started = 0;
+ lzx->error = MSPACK_ERR_OK;
+
+ /* window bits: 15 16 17 18 19 20 21
+ * position slots: 30 32 34 36 38 42 50 */
+ lzx->posn_slots = ((window_bits == 21) ? 50 :
+ ((window_bits == 20) ? 42 : (window_bits << 1)));
+
+ lzx->o_ptr = lzx->o_end = &lzx->e8_buf[0];
+ lzxd_reset_state(lzx);
+ INIT_BITS;
+ return lzx;
+}
+
+void lzxd_set_output_length(struct lzxd_stream *lzx, off_t out_bytes) {
+ if (lzx) lzx->length = out_bytes;
+}
+
+int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) {
+ /* bitstream and huffman reading variables */
+ register unsigned int bit_buffer;
+ register int bits_left, i=0;
+ unsigned char *i_ptr, *i_end;
+ register unsigned short sym;
+
+ int match_length, length_footer, extra, verbatim_bits, bytes_todo;
+ int this_run, main_element, aligned_bits, j;
+ unsigned char *window, *runsrc, *rundest, buf[12];
+ unsigned int frame_size=0, end_frame, match_offset, window_posn;
+ unsigned int R0, R1, R2;
+
+ /* easy answers */
+ if (!lzx || (out_bytes < 0)) return MSPACK_ERR_ARGS;
+ if (lzx->error) return lzx->error;
+
+ /* flush out any stored-up bytes before we begin */
+ i = lzx->o_end - lzx->o_ptr;
+ if ((off_t) i > out_bytes) i = (int) out_bytes;
+ if (i) {
+ if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) {
+ return lzx->error = MSPACK_ERR_WRITE;
+ }
+ lzx->o_ptr += i;
+ lzx->offset += i;
+ out_bytes -= i;
+ }
+ if (out_bytes == 0) return MSPACK_ERR_OK;
+
+ /* restore local state */
+ RESTORE_BITS;
+ window = lzx->window;
+ window_posn = lzx->window_posn;
+ R0 = lzx->R0;
+ R1 = lzx->R1;
+ R2 = lzx->R2;
+
+ end_frame = (unsigned int)((lzx->offset + out_bytes) / LZX_FRAME_SIZE) + 1;
+
+ while (lzx->frame < end_frame) {
+ /* have we reached the reset interval? (if there is one?) */
+ if (lzx->reset_interval && ((lzx->frame % lzx->reset_interval) == 0)) {
+ if (lzx->block_remaining) {
+ D(("%d bytes remaining at reset interval", lzx->block_remaining))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* re-read the intel header and reset the huffman lengths */
+ lzxd_reset_state(lzx);
+ R0 = lzx->R0;
+ R1 = lzx->R1;
+ R2 = lzx->R2;
+ }
+
+ /* read header if necessary */
+ if (!lzx->header_read) {
+ /* read 1 bit. if bit=0, intel filesize = 0.
+ * if bit=1, read intel filesize (32 bits) */
+ j = 0; READ_BITS(i, 1); if (i) { READ_BITS(i, 16); READ_BITS(j, 16); }
+ lzx->intel_filesize = (i << 16) | j;
+ lzx->header_read = 1;
+ }
+
+ /* calculate size of frame: all frames are 32k except the final frame
+ * which is 32kb or less. this can only be calculated when lzx->length
+ * has been filled in. */
+ frame_size = LZX_FRAME_SIZE;
+ if (lzx->length && (lzx->length - lzx->offset) < (off_t)frame_size) {
+ frame_size = lzx->length - lzx->offset;
+ }
+
+ /* decode until one more frame is available */
+ bytes_todo = lzx->frame_posn + frame_size - window_posn;
+ while (bytes_todo > 0) {
+ /* initialise new block, if one is needed */
+ if (lzx->block_remaining == 0) {
+ /* realign if previous block was an odd-sized UNCOMPRESSED block */
+ if ((lzx->block_type == LZX_BLOCKTYPE_UNCOMPRESSED) &&
+ (lzx->block_length & 1))
+ {
+ READ_IF_NEEDED;
+ i_ptr++;
+ }
+
+ /* read block type (3 bits) and block length (24 bits) */
+ READ_BITS(lzx->block_type, 3);
+ READ_BITS(i, 16); READ_BITS(j, 8);
+ lzx->block_remaining = lzx->block_length = (i << 8) | j;
+ /*D(("new block t%d len %u", lzx->block_type, lzx->block_length))*/
+
+ /* read individual block headers */
+ switch (lzx->block_type) {
+ case LZX_BLOCKTYPE_ALIGNED:
+ /* read lengths of and build aligned huffman decoding tree */
+ for (i = 0; i < 8; i++) { READ_BITS(j, 3); lzx->ALIGNED_len[i] = j; }
+ BUILD_TABLE(ALIGNED);
+ /* no break -- rest of aligned header is same as verbatim */
+ case LZX_BLOCKTYPE_VERBATIM:
+ /* read lengths of and build main huffman decoding tree */
+ READ_LENGTHS(MAINTREE, 0, 256);
+ READ_LENGTHS(MAINTREE, 256, LZX_NUM_CHARS + (lzx->posn_slots << 3));
+ BUILD_TABLE(MAINTREE);
+ /* if the literal 0xE8 is anywhere in the block... */
+ if (lzx->MAINTREE_len[0xE8] != 0) lzx->intel_started = 1;
+ /* read lengths of and build lengths huffman decoding tree */
+ READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS);
+ BUILD_TABLE_MAYBE_EMPTY(LENGTH);
+ break;
+
+ case LZX_BLOCKTYPE_UNCOMPRESSED:
+ /* because we can't assume otherwise */
+ lzx->intel_started = 1;
+
+ /* read 1-16 (not 0-15) bits to align to bytes */
+ ENSURE_BITS(16);
+ if (bits_left > 16) i_ptr -= 2;
+ bits_left = 0; bit_buffer = 0;
+
+ /* read 12 bytes of stored R0 / R1 / R2 values */
+ for (rundest = &buf[0], i = 0; i < 12; i++) {
+ READ_IF_NEEDED;
+ *rundest++ = *i_ptr++;
+ }
+ R0 = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
+ R1 = buf[4] | (buf[5] << 8) | (buf[6] << 16) | (buf[7] << 24);
+ R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24);
+ break;
+
+ default:
+ D(("bad block type"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ }
+
+ /* decode more of the block:
+ * run = min(what's available, what's needed) */
+ this_run = lzx->block_remaining;
+ if (this_run > bytes_todo) this_run = bytes_todo;
+
+ /* assume we decode exactly this_run bytes, for now */
+ bytes_todo -= this_run;
+ lzx->block_remaining -= this_run;
+
+ /* decode at least this_run bytes */
+ switch (lzx->block_type) {
+ case LZX_BLOCKTYPE_VERBATIM:
+ while (this_run > 0) {
+ READ_HUFFSYM(MAINTREE, main_element);
+ if (main_element < LZX_NUM_CHARS) {
+ /* literal: 0 to LZX_NUM_CHARS-1 */
+ window[window_posn++] = main_element;
+ this_run--;
+ }
+ else {
+ /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+ main_element -= LZX_NUM_CHARS;
+
+ /* get match length */
+ match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+ if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
+ if (lzx->LENGTH_empty) {
+ D(("LENGTH symbol needed but tree is empty"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ READ_HUFFSYM(LENGTH, length_footer);
+ match_length += length_footer;
+ }
+ match_length += LZX_MIN_MATCH;
+
+ /* get match offset */
+ switch ((match_offset = (main_element >> 3))) {
+ case 0: match_offset = R0; break;
+ case 1: match_offset = R1; R1=R0; R0 = match_offset; break;
+ case 2: match_offset = R2; R2=R0; R0 = match_offset; break;
+ case 3: match_offset = 1; R2=R1; R1=R0; R0 = match_offset; break;
+ default:
+ extra = extra_bits[match_offset];
+ READ_BITS(verbatim_bits, extra);
+ match_offset = position_base[match_offset] - 2 + verbatim_bits;
+ R2 = R1; R1 = R0; R0 = match_offset;
+ }
+
+ if ((window_posn + match_length) > lzx->window_size) {
+ D(("match ran over window wrap"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* copy match */
+ rundest = &window[window_posn];
+ i = match_length;
+ /* does match offset wrap the window? */
+ if (match_offset > window_posn) {
+ /* j = length from match offset to end of window */
+ j = match_offset - window_posn;
+ if (j > (int) lzx->window_size) {
+ D(("match offset beyond window boundaries"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ runsrc = &window[lzx->window_size - j];
+ if (j < i) {
+ /* if match goes over the window edge, do two copy runs */
+ i -= j; while (j-- > 0) *rundest++ = *runsrc++;
+ runsrc = window;
+ }
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+ else {
+ runsrc = rundest - match_offset;
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+
+ this_run -= match_length;
+ window_posn += match_length;
+ }
+ } /* while (this_run > 0) */
+ break;
+
+ case LZX_BLOCKTYPE_ALIGNED:
+ while (this_run > 0) {
+ READ_HUFFSYM(MAINTREE, main_element);
+ if (main_element < LZX_NUM_CHARS) {
+ /* literal: 0 to LZX_NUM_CHARS-1 */
+ window[window_posn++] = main_element;
+ this_run--;
+ }
+ else {
+ /* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+ main_element -= LZX_NUM_CHARS;
+
+ /* get match length */
+ match_length = main_element & LZX_NUM_PRIMARY_LENGTHS;
+ if (match_length == LZX_NUM_PRIMARY_LENGTHS) {
+ if (lzx->LENGTH_empty) {
+ D(("LENGTH symbol needed but tree is empty"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ READ_HUFFSYM(LENGTH, length_footer);
+ match_length += length_footer;
+ }
+ match_length += LZX_MIN_MATCH;
+
+ /* get match offset */
+ switch ((match_offset = (main_element >> 3))) {
+ case 0: match_offset = R0; break;
+ case 1: match_offset = R1; R1 = R0; R0 = match_offset; break;
+ case 2: match_offset = R2; R2 = R0; R0 = match_offset; break;
+ default:
+ extra = extra_bits[match_offset];
+ match_offset = position_base[match_offset] - 2;
+ if (extra > 3) {
+ /* verbatim and aligned bits */
+ extra -= 3;
+ READ_BITS(verbatim_bits, extra);
+ match_offset += (verbatim_bits << 3);
+ READ_HUFFSYM(ALIGNED, aligned_bits);
+ match_offset += aligned_bits;
+ }
+ else if (extra == 3) {
+ /* aligned bits only */
+ READ_HUFFSYM(ALIGNED, aligned_bits);
+ match_offset += aligned_bits;
+ }
+ else if (extra > 0) { /* extra==1, extra==2 */
+ /* verbatim bits only */
+ READ_BITS(verbatim_bits, extra);
+ match_offset += verbatim_bits;
+ }
+ else /* extra == 0 */ {
+ /* ??? not defined in LZX specification! */
+ match_offset = 1;
+ }
+ /* update repeated offset LRU queue */
+ R2 = R1; R1 = R0; R0 = match_offset;
+ }
+
+ if ((window_posn + match_length) > lzx->window_size) {
+ D(("match ran over window wrap"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* copy match */
+ rundest = &window[window_posn];
+ i = match_length;
+ /* does match offset wrap the window? */
+ if (match_offset > window_posn) {
+ /* j = length from match offset to end of window */
+ j = match_offset - window_posn;
+ if (j > (int) lzx->window_size) {
+ D(("match offset beyond window boundaries"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ runsrc = &window[lzx->window_size - j];
+ if (j < i) {
+ /* if match goes over the window edge, do two copy runs */
+ i -= j; while (j-- > 0) *rundest++ = *runsrc++;
+ runsrc = window;
+ }
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+ else {
+ runsrc = rundest - match_offset;
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+
+ this_run -= match_length;
+ window_posn += match_length;
+ }
+ } /* while (this_run > 0) */
+ break;
+
+ case LZX_BLOCKTYPE_UNCOMPRESSED:
+ /* as this_run is limited not to wrap a frame, this also means it
+ * won't wrap the window (as the window is a multiple of 32k) */
+ rundest = &window[window_posn];
+ window_posn += this_run;
+ while (this_run > 0) {
+ if ((i = i_end - i_ptr) == 0) {
+ READ_IF_NEEDED;
+ }
+ else {
+ if (i > this_run) i = this_run;
+ lzx->sys->copy(i_ptr, rundest, (size_t) i);
+ rundest += i;
+ i_ptr += i;
+ this_run -= i;
+ }
+ }
+ break;
+
+ default:
+ return lzx->error = MSPACK_ERR_DECRUNCH; /* might as well */
+ }
+
+ /* did the final match overrun our desired this_run length? */
+ if (this_run < 0) {
+ if ((unsigned int)(-this_run) > lzx->block_remaining) {
+ D(("overrun went past end of block by %d (%d remaining)",
+ -this_run, lzx->block_remaining ))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+ lzx->block_remaining -= -this_run;
+ }
+ } /* while (bytes_todo > 0) */
+
+ /* streams don't extend over frame boundaries */
+ if ((window_posn - lzx->frame_posn) != frame_size) {
+ D(("decode beyond output frame limits! %d != %d",
+ window_posn - lzx->frame_posn, frame_size))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* re-align input bitstream */
+ if (bits_left > 0) ENSURE_BITS(16);
+ if (bits_left & 15) REMOVE_BITS(bits_left & 15);
+
+ /* check that we've used all of the previous frame first */
+ if (lzx->o_ptr != lzx->o_end) {
+ D(("%ld avail bytes, new %d frame", lzx->o_end-lzx->o_ptr, frame_size))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* does this intel block _really_ need decoding? */
+ if (lzx->intel_started && lzx->intel_filesize &&
+ (lzx->frame <= 32768) && (frame_size > 10))
+ {
+ unsigned char *data = &lzx->e8_buf[0];
+ unsigned char *dataend = &lzx->e8_buf[frame_size - 10];
+ signed int curpos = lzx->intel_curpos;
+ signed int filesize = lzx->intel_filesize;
+ signed int abs_off, rel_off;
+
+ /* copy e8 block to the e8 buffer and tweak if needed */
+ lzx->o_ptr = data;
+ lzx->sys->copy(&lzx->window[lzx->frame_posn], data, frame_size);
+
+ while (data < dataend) {
+ if (*data++ != 0xE8) { curpos++; continue; }
+ abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
+ if ((abs_off >= -curpos) && (abs_off < filesize)) {
+ rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize;
+ data[0] = (unsigned char) rel_off;
+ data[1] = (unsigned char) (rel_off >> 8);
+ data[2] = (unsigned char) (rel_off >> 16);
+ data[3] = (unsigned char) (rel_off >> 24);
+ }
+ data += 4;
+ curpos += 5;
+ }
+ lzx->intel_curpos += frame_size;
+ }
+ else {
+ lzx->o_ptr = &lzx->window[lzx->frame_posn];
+ if (lzx->intel_filesize) lzx->intel_curpos += frame_size;
+ }
+ lzx->o_end = &lzx->o_ptr[frame_size];
+
+ /* write a frame */
+ i = (out_bytes < (off_t)frame_size) ? (unsigned int)out_bytes : frame_size;
+ if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) {
+ return lzx->error = MSPACK_ERR_WRITE;
+ }
+ lzx->o_ptr += i;
+ lzx->offset += i;
+ out_bytes -= i;
+
+ /* advance frame start position */
+ lzx->frame_posn += frame_size;
+ lzx->frame++;
+
+ /* wrap window / frame position pointers */
+ if (window_posn == lzx->window_size) window_posn = 0;
+ if (lzx->frame_posn == lzx->window_size) lzx->frame_posn = 0;
+
+ } /* while (lzx->frame < end_frame) */
+
+ if (out_bytes) {
+ D(("bytes left to output"))
+ return lzx->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* store local state */
+ STORE_BITS;
+ lzx->window_posn = window_posn;
+ lzx->R0 = R0;
+ lzx->R1 = R1;
+ lzx->R2 = R2;
+
+ return MSPACK_ERR_OK;
+}
+
+void lzxd_free(struct lzxd_stream *lzx) {
+ struct mspack_system *sys;
+ if (lzx) {
+ sys = lzx->sys;
+ sys->free(lzx->inbuf);
+ sys->free(lzx->window);
+ sys->free(lzx);
+ }
+}
diff --git a/rbutil/rbutilqt/mspack/mspack.h b/rbutil/rbutilqt/mspack/mspack.h
new file mode 100644
index 0000000000..7f6bdf1465
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/mspack.h
@@ -0,0 +1,2203 @@
+/* libmspack -- a library for working with Microsoft compression formats.
+ * (C) 2003-2011 Stuart Caie <kyzer@4u.net>
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/** \mainpage
+ *
+ * \section intro Introduction
+ *
+ * libmspack is a library which provides compressors and decompressors,
+ * archivers and dearchivers for Microsoft compression formats.
+ *
+ * \section formats Formats supported
+ *
+ * The following file formats are supported:
+ * - SZDD files, which use LZSS compression
+ * - KWAJ files, which use LZSS, LZSS+Huffman or deflate compression
+ * - .HLP (MS Help) files, which use LZSS compression
+ * - .CAB (MS Cabinet) files, which use deflate, LZX or Quantum compression
+ * - .CHM (HTML Help) files, which use LZX compression
+ * - .LIT (MS EBook) files, which use LZX compression and DES encryption
+ *
+ * To determine the capabilities of the library, and the binary
+ * compatibility version of any particular compressor or decompressor, use
+ * the mspack_version() function. The UNIX library interface version is
+ * defined as the highest-versioned library component.
+ *
+ * \section starting Getting started
+ *
+ * The macro MSPACK_SYS_SELFTEST() should be used to ensure the library can
+ * be used. In particular, it checks if the caller is using 32-bit file I/O
+ * when the library is compiled for 64-bit file I/O and vice versa.
+ *
+ * If compiled normally, the library includes basic file I/O and memory
+ * management functionality using the standard C library. This can be
+ * customised and replaced entirely by creating a mspack_system structure.
+ *
+ * A compressor or decompressor for the required format must be
+ * instantiated before it can be used. Each construction function takes
+ * one parameter, which is either a pointer to a custom mspack_system
+ * structure, or NULL to use the default. The instantiation returned, if
+ * not NULL, contains function pointers (methods) to work with the given
+ * file format.
+ *
+ * For compression:
+ * - mspack_create_cab_compressor() creates a mscab_compressor
+ * - mspack_create_chm_compressor() creates a mschm_compressor
+ * - mspack_create_lit_compressor() creates a mslit_compressor
+ * - mspack_create_hlp_compressor() creates a mshlp_compressor
+ * - mspack_create_szdd_compressor() creates a msszdd_compressor
+ * - mspack_create_kwaj_compressor() creates a mskwaj_compressor
+ *
+ * For decompression:
+ * - mspack_create_cab_decompressor() creates a mscab_decompressor
+ * - mspack_create_chm_decompressor() creates a mschm_decompressor
+ * - mspack_create_lit_decompressor() creates a mslit_decompressor
+ * - mspack_create_hlp_decompressor() creates a mshlp_decompressor
+ * - mspack_create_szdd_decompressor() creates a msszdd_decompressor
+ * - mspack_create_kwaj_decompressor() creates a mskwaj_decompressor
+ *
+ * Once finished working with a format, each kind of
+ * compressor/decompressor has its own specific destructor:
+ * - mspack_destroy_cab_compressor()
+ * - mspack_destroy_cab_decompressor()
+ * - mspack_destroy_chm_compressor()
+ * - mspack_destroy_chm_decompressor()
+ * - mspack_destroy_lit_compressor()
+ * - mspack_destroy_lit_decompressor()
+ * - mspack_destroy_hlp_compressor()
+ * - mspack_destroy_hlp_decompressor()
+ * - mspack_destroy_szdd_compressor()
+ * - mspack_destroy_szdd_decompressor()
+ * - mspack_destroy_kwaj_compressor()
+ * - mspack_destroy_kwaj_decompressor()
+ *
+ * Destroying a compressor or decompressor does not destroy any objects,
+ * structures or handles that have been created using that compressor or
+ * decompressor. Ensure that everything created or opened is destroyed or
+ * closed before compressor/decompressor is itself destroyed.
+ *
+ * \section errors Error codes
+ *
+ * All compressors and decompressors use the same set of error codes. Most
+ * methods return an error code directly. For methods which do not
+ * return error codes directly, the error code can be obtained with the
+ * last_error() method.
+ *
+ * - #MSPACK_ERR_OK is used to indicate success. This error code is defined
+ * as zero, all other code are non-zero.
+ * - #MSPACK_ERR_ARGS indicates that a method was called with inappropriate
+ * arguments.
+ * - #MSPACK_ERR_OPEN indicates that mspack_system::open() failed.
+ * - #MSPACK_ERR_READ indicates that mspack_system::read() failed.
+ * - #MSPACK_ERR_WRITE indicates that mspack_system::write() failed.
+ * - #MSPACK_ERR_SEEK indicates that mspack_system::seek() failed.
+ * - #MSPACK_ERR_NOMEMORY indicates that mspack_system::alloc() failed.
+ * - #MSPACK_ERR_SIGNATURE indicates that the file being read does not
+ * have the correct "signature". It is probably not a valid file for
+ * whatever format is being read.
+ * - #MSPACK_ERR_DATAFORMAT indicates that the file being used or read
+ * is corrupt.
+ * - #MSPACK_ERR_CHECKSUM indicates that a data checksum has failed.
+ * - #MSPACK_ERR_CRUNCH indicates an error occured during compression.
+ * - #MSPACK_ERR_DECRUNCH indicates an error occured during decompression.
+ *
+ * \section threading Multi-threading
+ *
+ * libmspack methods are reentrant and multithreading-safe when each
+ * thread has its own compressor or decompressor.
+
+ * You should not call multiple methods simultaneously on a single
+ * compressor or decompressor instance.
+ *
+ * If this may happen, you can either use one compressor or
+ * decompressor per thread, or you can use your preferred lock,
+ * semaphore or mutex library to ensure no more than one method on a
+ * compressor/decompressor is called simultaneously. libmspack will
+ * not do this locking for you.
+ *
+ * Example of incorrect behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 1 calls open()
+ * - thread 1 calls extract() for one file
+ * - thread 2 simultaneously calls extract() for another file
+ *
+ * Correct behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 2 calls mspack_create_cab_decompressor()
+ * - thread 1 calls its own open() / extract()
+ * - thread 2 simultaneously calls its own open() / extract()
+ *
+ * Also correct behaviour:
+ * - thread 1 calls mspack_create_cab_decompressor()
+ * - thread 1 locks a mutex for with the decompressor before
+ * calling any methods on it, and unlocks the mutex after each
+ * method returns.
+ * - thread 1 can share the results of open() with thread 2, and both
+ * can call extract(), provided they both guard against simultaneous
+ * use of extract(), and any other methods, with the mutex
+ */
+
+#ifndef LIB_MSPACK_H
+#define LIB_MSPACK_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/types.h>
+#include <stdlib.h>
+
+/**
+ * System self-test function, to ensure both library and calling program
+ * can use one another.
+ *
+ * A result of MSPACK_ERR_OK means the library and caller are
+ * compatible. Any other result indicates that the library and caller are
+ * not compatible and should not be used. In particular, a value of
+ * MSPACK_ERR_SEEK means the library and caller use different off_t
+ * datatypes.
+ *
+ * It should be used like so:
+ *
+ * @code
+ * int selftest_result;
+ * MSPACK_SYS_SELFTEST(selftest_result);
+ * if (selftest_result != MSPACK_ERR_OK) {
+ * fprintf(stderr, "incompatible with this build of libmspack\n");
+ * exit(0);
+ * }
+ * @endcode
+ *
+ * @param result an int variable to store the result of the self-test
+ */
+#define MSPACK_SYS_SELFTEST(result) do { \
+ (result) = mspack_sys_selftest_internal(sizeof(off_t)); \
+} while (0)
+
+/** Part of the MSPACK_SYS_SELFTEST() macro, must not be used directly. */
+extern int mspack_sys_selftest_internal(int);
+
+/**
+ * Enquire about the binary compatibility version of a specific interface in
+ * the library. Currently, the following interfaces are defined:
+ *
+ * - #MSPACK_VER_LIBRARY: the overall library
+ * - #MSPACK_VER_SYSTEM: the mspack_system interface
+ * - #MSPACK_VER_MSCABD: the mscab_decompressor interface
+ * - #MSPACK_VER_MSCABC: the mscab_compressor interface
+ * - #MSPACK_VER_MSCHMD: the mschm_decompressor interface
+ * - #MSPACK_VER_MSCHMC: the mschm_compressor interface
+ * - #MSPACK_VER_MSLITD: the mslit_decompressor interface
+ * - #MSPACK_VER_MSLITC: the mslit_compressor interface
+ * - #MSPACK_VER_MSHLPD: the mshlp_decompressor interface
+ * - #MSPACK_VER_MSHLPC: the mshlp_compressor interface
+ * - #MSPACK_VER_MSSZDDD: the msszdd_decompressor interface
+ * - #MSPACK_VER_MSSZDDC: the msszdd_compressor interface
+ * - #MSPACK_VER_MSKWAJD: the mskwaj_decompressor interface
+ * - #MSPACK_VER_MSKWAJC: the mskwaj_compressor interface
+ *
+ * The result of the function should be interpreted as follows:
+ * - -1: this interface is completely unknown to the library
+ * - 0: this interface is known, but non-functioning
+ * - 1: this interface has all basic functionality
+ * - 2, 3, ...: this interface has additional functionality, clearly marked
+ * in the documentation as "version 2", "version 3" and so on.
+ *
+ * @param entity the interface to request current version of
+ * @return the version of the requested interface
+ */
+extern int mspack_version(int entity);
+
+/** Pass to mspack_version() to get the overall library version */
+#define MSPACK_VER_LIBRARY (0)
+/** Pass to mspack_version() to get the mspack_system version */
+#define MSPACK_VER_SYSTEM (1)
+/** Pass to mspack_version() to get the mscab_decompressor version */
+#define MSPACK_VER_MSCABD (2)
+/** Pass to mspack_version() to get the mscab_compressor version */
+#define MSPACK_VER_MSCABC (3)
+/** Pass to mspack_version() to get the mschm_decompressor version */
+#define MSPACK_VER_MSCHMD (4)
+/** Pass to mspack_version() to get the mschm_compressor version */
+#define MSPACK_VER_MSCHMC (5)
+/** Pass to mspack_version() to get the mslit_decompressor version */
+#define MSPACK_VER_MSLITD (6)
+/** Pass to mspack_version() to get the mslit_compressor version */
+#define MSPACK_VER_MSLITC (7)
+/** Pass to mspack_version() to get the mshlp_decompressor version */
+#define MSPACK_VER_MSHLPD (8)
+/** Pass to mspack_version() to get the mshlp_compressor version */
+#define MSPACK_VER_MSHLPC (9)
+/** Pass to mspack_version() to get the msszdd_decompressor version */
+#define MSPACK_VER_MSSZDDD (10)
+/** Pass to mspack_version() to get the msszdd_compressor version */
+#define MSPACK_VER_MSSZDDC (11)
+/** Pass to mspack_version() to get the mskwaj_decompressor version */
+#define MSPACK_VER_MSKWAJD (12)
+/** Pass to mspack_version() to get the mskwaj_compressor version */
+#define MSPACK_VER_MSKWAJC (13)
+
+/* --- file I/O abstraction ------------------------------------------------ */
+
+/**
+ * A structure which abstracts file I/O and memory management.
+ *
+ * The library always uses the mspack_system structure for interaction
+ * with the file system and to allocate, free and copy all memory. It also
+ * uses it to send literal messages to the library user.
+ *
+ * When the library is compiled normally, passing NULL to a compressor or
+ * decompressor constructor will result in a default mspack_system being
+ * used, where all methods are implemented with the standard C library.
+ * However, all constructors support being given a custom created
+ * mspack_system structure, with the library user's own methods. This
+ * allows for more abstract interaction, such as reading and writing files
+ * directly to memory, or from a network socket or pipe.
+ *
+ * Implementors of an mspack_system structure should read all
+ * documentation entries for every structure member, and write methods
+ * which conform to those standards.
+ */
+struct mspack_system {
+ /**
+ * Opens a file for reading, writing, appending or updating.
+ *
+ * @param self a self-referential pointer to the mspack_system
+ * structure whose open() method is being called. If
+ * this pointer is required by close(), read(), write(),
+ * seek() or tell(), it should be stored in the result
+ * structure at this time.
+ * @param filename the file to be opened. It is passed directly from the
+ * library caller without being modified, so it is up to
+ * the caller what this parameter actually represents.
+ * @param mode one of #MSPACK_SYS_OPEN_READ (open an existing file
+ * for reading), #MSPACK_SYS_OPEN_WRITE (open a new file
+ * for writing), #MSPACK_SYS_OPEN_UPDATE (open an existing
+ * file for reading/writing from the start of the file) or
+ * #MSPACK_SYS_OPEN_APPEND (open an existing file for
+ * reading/writing from the end of the file)
+ * @return a pointer to a mspack_file structure. This structure officially
+ * contains no members, its true contents are up to the
+ * mspack_system implementor. It should contain whatever is needed
+ * for other mspack_system methods to operate. Returning the NULL
+ * pointer indicates an error condition.
+ * @see close(), read(), write(), seek(), tell(), message()
+ */
+ struct mspack_file * (*open)(struct mspack_system *self,
+ const char *filename,
+ int mode);
+
+ /**
+ * Closes a previously opened file. If any memory was allocated for this
+ * particular file handle, it should be freed at this time.
+ *
+ * @param file the file to close
+ * @see open()
+ */
+ void (*close)(struct mspack_file *file);
+
+ /**
+ * Reads a given number of bytes from an open file.
+ *
+ * @param file the file to read from
+ * @param buffer the location where the read bytes should be stored
+ * @param bytes the number of bytes to read from the file.
+ * @return the number of bytes successfully read (this can be less than
+ * the number requested), zero to mark the end of file, or less
+ * than zero to indicate an error.
+ * @see open(), write()
+ */
+ int (*read)(struct mspack_file *file,
+ void *buffer,
+ int bytes);
+
+ /**
+ * Writes a given number of bytes to an open file.
+ *
+ * @param file the file to write to
+ * @param buffer the location where the written bytes should be read from
+ * @param bytes the number of bytes to write to the file.
+ * @return the number of bytes successfully written, this can be less
+ * than the number requested. Zero or less can indicate an error
+ * where no bytes at all could be written. All cases where less
+ * bytes were written than requested are considered by the library
+ * to be an error.
+ * @see open(), read()
+ */
+ int (*write)(struct mspack_file *file,
+ void *buffer,
+ int bytes);
+
+ /**
+ * Seeks to a specific file offset within an open file.
+ *
+ * Sometimes the library needs to know the length of a file. It does
+ * this by seeking to the end of the file with seek(file, 0,
+ * MSPACK_SYS_SEEK_END), then calling tell(). Implementations may want
+ * to make a special case for this.
+ *
+ * Due to the potentially varying 32/64 bit datatype off_t on some
+ * architectures, the #MSPACK_SYS_SELFTEST macro MUST be used before
+ * using the library. If not, the error caused by the library passing an
+ * inappropriate stackframe to seek() is subtle and hard to trace.
+ *
+ * @param file the file to be seeked
+ * @param offset an offset to seek, measured in bytes
+ * @param mode one of #MSPACK_SYS_SEEK_START (the offset should be
+ * measured from the start of the file), #MSPACK_SYS_SEEK_CUR
+ * (the offset should be measured from the current file offset)
+ * or #MSPACK_SYS_SEEK_END (the offset should be measured from
+ * the end of the file)
+ * @return zero for success, non-zero for an error
+ * @see open(), tell()
+ */
+ int (*seek)(struct mspack_file *file,
+ off_t offset,
+ int mode);
+
+ /**
+ * Returns the current file position (in bytes) of the given file.
+ *
+ * @param file the file whose file position is wanted
+ * @return the current file position of the file
+ * @see open(), seek()
+ */
+ off_t (*tell)(struct mspack_file *file);
+
+ /**
+ * Used to send messages from the library to the user.
+ *
+ * Occasionally, the library generates warnings or other messages in
+ * plain english to inform the human user. These are informational only
+ * and can be ignored if not wanted.
+ *
+ * @param file may be a file handle returned from open() if this message
+ * pertains to a specific open file, or NULL if not related to
+ * a specific file.
+ * @param format a printf() style format string. It does NOT include a
+ * trailing newline.
+ * @see open()
+ */
+ void (*message)(struct mspack_file *file,
+ const char *format,
+ ...);
+
+ /**
+ * Allocates memory.
+ *
+ * @param self a self-referential pointer to the mspack_system
+ * structure whose alloc() method is being called.
+ * @param bytes the number of bytes to allocate
+ * @result a pointer to the requested number of bytes, or NULL if
+ * not enough memory is available
+ * @see free()
+ */
+ void * (*alloc)(struct mspack_system *self,
+ size_t bytes);
+
+ /**
+ * Frees memory.
+ *
+ * @param ptr the memory to be freed.
+ * @see alloc()
+ */
+ void (*free)(void *ptr);
+
+ /**
+ * Copies from one region of memory to another.
+ *
+ * The regions of memory are guaranteed not to overlap, are usually less
+ * than 256 bytes, and may not be aligned. Please note that the source
+ * parameter comes before the destination parameter, unlike the standard
+ * C function memcpy().
+ *
+ * @param src the region of memory to copy from
+ * @param dest the region of memory to copy to
+ * @param bytes the size of the memory region, in bytes
+ */
+ void (*copy)(void *src,
+ void *dest,
+ size_t bytes);
+
+ /**
+ * A null pointer to mark the end of mspack_system. It must equal NULL.
+ *
+ * Should the mspack_system structure extend in the future, this NULL
+ * will be seen, rather than have an invalid method pointer called.
+ */
+ void *null_ptr;
+};
+
+/** mspack_system::open() mode: open existing file for reading. */
+#define MSPACK_SYS_OPEN_READ (0)
+/** mspack_system::open() mode: open new file for writing */
+#define MSPACK_SYS_OPEN_WRITE (1)
+/** mspack_system::open() mode: open existing file for writing */
+#define MSPACK_SYS_OPEN_UPDATE (2)
+/** mspack_system::open() mode: open existing file for writing */
+#define MSPACK_SYS_OPEN_APPEND (3)
+
+/** mspack_system::seek() mode: seek relative to start of file */
+#define MSPACK_SYS_SEEK_START (0)
+/** mspack_system::seek() mode: seek relative to current offset */
+#define MSPACK_SYS_SEEK_CUR (1)
+/** mspack_system::seek() mode: seek relative to end of file */
+#define MSPACK_SYS_SEEK_END (2)
+
+/**
+ * A structure which represents an open file handle. The contents of this
+ * structure are determined by the implementation of the
+ * mspack_system::open() method.
+ */
+struct mspack_file {
+ int dummy;
+};
+
+/* --- error codes --------------------------------------------------------- */
+
+/** Error code: no error */
+#define MSPACK_ERR_OK (0)
+/** Error code: bad arguments to method */
+#define MSPACK_ERR_ARGS (1)
+/** Error code: error opening file */
+#define MSPACK_ERR_OPEN (2)
+/** Error code: error reading file */
+#define MSPACK_ERR_READ (3)
+/** Error code: error writing file */
+#define MSPACK_ERR_WRITE (4)
+/** Error code: seek error */
+#define MSPACK_ERR_SEEK (5)
+/** Error code: out of memory */
+#define MSPACK_ERR_NOMEMORY (6)
+/** Error code: bad "magic id" in file */
+#define MSPACK_ERR_SIGNATURE (7)
+/** Error code: bad or corrupt file format */
+#define MSPACK_ERR_DATAFORMAT (8)
+/** Error code: bad checksum or CRC */
+#define MSPACK_ERR_CHECKSUM (9)
+/** Error code: error during compression */
+#define MSPACK_ERR_CRUNCH (10)
+/** Error code: error during decompression */
+#define MSPACK_ERR_DECRUNCH (11)
+
+/* --- functions available in library -------------------------------------- */
+
+/** Creates a new CAB compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mscab_compressor or NULL
+ */
+extern struct mscab_compressor *
+ mspack_create_cab_compressor(struct mspack_system *sys);
+
+/** Creates a new CAB decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mscab_decompressor or NULL
+ */
+extern struct mscab_decompressor *
+ mspack_create_cab_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing CAB compressor.
+ * @param self the #mscab_compressor to destroy
+ */
+extern void mspack_destroy_cab_compressor(struct mscab_compressor *self);
+
+/** Destroys an existing CAB decompressor.
+ * @param self the #mscab_decompressor to destroy
+ */
+extern void mspack_destroy_cab_decompressor(struct mscab_decompressor *self);
+
+
+/** Creates a new CHM compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mschm_compressor or NULL
+ */
+extern struct mschm_compressor *
+ mspack_create_chm_compressor(struct mspack_system *sys);
+
+/** Creates a new CHM decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mschm_decompressor or NULL
+ */
+extern struct mschm_decompressor *
+ mspack_create_chm_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing CHM compressor.
+ * @param self the #mschm_compressor to destroy
+ */
+extern void mspack_destroy_chm_compressor(struct mschm_compressor *self);
+
+/** Destroys an existing CHM decompressor.
+ * @param self the #mschm_decompressor to destroy
+ */
+extern void mspack_destroy_chm_decompressor(struct mschm_decompressor *self);
+
+
+/** Creates a new LIT compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mslit_compressor or NULL
+ */
+extern struct mslit_compressor *
+ mspack_create_lit_compressor(struct mspack_system *sys);
+
+/** Creates a new LIT decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mslit_decompressor or NULL
+ */
+extern struct mslit_decompressor *
+ mspack_create_lit_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing LIT compressor.
+ * @param self the #mslit_compressor to destroy
+ */
+extern void mspack_destroy_lit_compressor(struct mslit_compressor *self);
+
+/** Destroys an existing LIT decompressor.
+ * @param self the #mslit_decompressor to destroy
+ */
+extern void mspack_destroy_lit_decompressor(struct mslit_decompressor *self);
+
+
+/** Creates a new HLP compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mshlp_compressor or NULL
+ */
+extern struct mshlp_compressor *
+ mspack_create_hlp_compressor(struct mspack_system *sys);
+
+/** Creates a new HLP decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mshlp_decompressor or NULL
+ */
+extern struct mshlp_decompressor *
+ mspack_create_hlp_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing hlp compressor.
+ * @param self the #mshlp_compressor to destroy
+ */
+extern void mspack_destroy_hlp_compressor(struct mshlp_compressor *self);
+
+/** Destroys an existing hlp decompressor.
+ * @param self the #mshlp_decompressor to destroy
+ */
+extern void mspack_destroy_hlp_decompressor(struct mshlp_decompressor *self);
+
+
+/** Creates a new SZDD compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msszdd_compressor or NULL
+ */
+extern struct msszdd_compressor *
+ mspack_create_szdd_compressor(struct mspack_system *sys);
+
+/** Creates a new SZDD decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #msszdd_decompressor or NULL
+ */
+extern struct msszdd_decompressor *
+ mspack_create_szdd_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing SZDD compressor.
+ * @param self the #msszdd_compressor to destroy
+ */
+extern void mspack_destroy_szdd_compressor(struct msszdd_compressor *self);
+
+/** Destroys an existing SZDD decompressor.
+ * @param self the #msszdd_decompressor to destroy
+ */
+extern void mspack_destroy_szdd_decompressor(struct msszdd_decompressor *self);
+
+
+/** Creates a new KWAJ compressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mskwaj_compressor or NULL
+ */
+extern struct mskwaj_compressor *
+ mspack_create_kwaj_compressor(struct mspack_system *sys);
+
+/** Creates a new KWAJ decompressor.
+ * @param sys a custom mspack_system structure, or NULL to use the default
+ * @return a #mskwaj_decompressor or NULL
+ */
+extern struct mskwaj_decompressor *
+ mspack_create_kwaj_decompressor(struct mspack_system *sys);
+
+/** Destroys an existing KWAJ compressor.
+ * @param self the #mskwaj_compressor to destroy
+ */
+extern void mspack_destroy_kwaj_compressor(struct mskwaj_compressor *self);
+
+/** Destroys an existing KWAJ decompressor.
+ * @param self the #mskwaj_decompressor to destroy
+ */
+extern void mspack_destroy_kwaj_decompressor(struct mskwaj_decompressor *self);
+
+
+/* --- support for .CAB (MS Cabinet) file format --------------------------- */
+
+/**
+ * A structure which represents a single cabinet file.
+ *
+ * All fields are READ ONLY.
+ *
+ * If this cabinet is part of a merged cabinet set, the #files and #folders
+ * fields are common to all cabinets in the set, and will be identical.
+ *
+ * @see mscab_decompressor::open(), mscab_decompressor::close(),
+ * mscab_decompressor::search()
+ */
+struct mscabd_cabinet {
+ /**
+ * The next cabinet in a chained list, if this cabinet was opened with
+ * mscab_decompressor::search(). May be NULL to mark the end of the
+ * list.
+ */
+ struct mscabd_cabinet *next;
+
+ /**
+ * The filename of the cabinet. More correctly, the filename of the
+ * physical file that the cabinet resides in. This is given by the
+ * library user and may be in any format.
+ */
+ const char *filename;
+
+ /** The file offset of cabinet within the physical file it resides in. */
+ off_t base_offset;
+
+ /** The length of the cabinet file in bytes. */
+ unsigned int length;
+
+ /** The previous cabinet in a cabinet set, or NULL. */
+ struct mscabd_cabinet *prevcab;
+
+ /** The next cabinet in a cabinet set, or NULL. */
+ struct mscabd_cabinet *nextcab;
+
+ /** The filename of the previous cabinet in a cabinet set, or NULL. */
+ char *prevname;
+
+ /** The filename of the next cabinet in a cabinet set, or NULL. */
+ char *nextname;
+
+ /** The name of the disk containing the previous cabinet in a cabinet
+ * set, or NULL.
+ */
+ char *previnfo;
+
+ /** The name of the disk containing the next cabinet in a cabinet set,
+ * or NULL.
+ */
+ char *nextinfo;
+
+ /** A list of all files in the cabinet or cabinet set. */
+ struct mscabd_file *files;
+
+ /** A list of all folders in the cabinet or cabinet set. */
+ struct mscabd_folder *folders;
+
+ /**
+ * The set ID of the cabinet. All cabinets in the same set should have
+ * the same set ID.
+ */
+ unsigned short set_id;
+
+ /**
+ * The index number of the cabinet within the set. Numbering should
+ * start from 0 for the first cabinet in the set, and increment by 1 for
+ * each following cabinet.
+ */
+ unsigned short set_index;
+
+ /**
+ * The number of bytes reserved in the header area of the cabinet.
+ *
+ * If this is non-zero and flags has MSCAB_HDR_RESV set, this data can
+ * be read by the calling application. It is of the given length,
+ * located at offset (base_offset + MSCAB_HDR_RESV_OFFSET) in the
+ * cabinet file.
+ *
+ * @see flags
+ */
+ unsigned short header_resv;
+
+ /**
+ * Header flags.
+ *
+ * - MSCAB_HDR_PREVCAB indicates the cabinet is part of a cabinet set, and
+ * has a predecessor cabinet.
+ * - MSCAB_HDR_NEXTCAB indicates the cabinet is part of a cabinet set, and
+ * has a successor cabinet.
+ * - MSCAB_HDR_RESV indicates the cabinet has reserved header space.
+ *
+ * @see prevname, previnfo, nextname, nextinfo, header_resv
+ */
+ int flags;
+};
+
+/** Offset from start of cabinet to the reserved header data (if present). */
+#define MSCAB_HDR_RESV_OFFSET (0x28)
+
+/** Cabinet header flag: cabinet has a predecessor */
+#define MSCAB_HDR_PREVCAB (0x01)
+/** Cabinet header flag: cabinet has a successor */
+#define MSCAB_HDR_NEXTCAB (0x02)
+/** Cabinet header flag: cabinet has reserved header space */
+#define MSCAB_HDR_RESV (0x04)
+
+/**
+ * A structure which represents a single folder in a cabinet or cabinet set.
+ *
+ * All fields are READ ONLY.
+ *
+ * A folder is a single compressed stream of data. When uncompressed, it
+ * holds the data of one or more files. A folder may be split across more
+ * than one cabinet.
+ */
+struct mscabd_folder {
+ /**
+ * A pointer to the next folder in this cabinet or cabinet set, or NULL
+ * if this is the final folder.
+ */
+ struct mscabd_folder *next;
+
+ /**
+ * The compression format used by this folder.
+ *
+ * The macro MSCABD_COMP_METHOD() should be used on this field to get
+ * the algorithm used. The macro MSCABD_COMP_LEVEL() should be used to get
+ * the "compression level".
+ *
+ * @see MSCABD_COMP_METHOD(), MSCABD_COMP_LEVEL()
+ */
+ int comp_type;
+
+ /**
+ * The total number of data blocks used by this folder. This includes
+ * data blocks present in other files, if this folder spans more than
+ * one cabinet.
+ */
+ unsigned int num_blocks;
+};
+
+/**
+ * Returns the compression method used by a folder.
+ *
+ * @param comp_type a mscabd_folder::comp_type value
+ * @return one of #MSCAB_COMP_NONE, #MSCAB_COMP_MSZIP, #MSCAB_COMP_QUANTUM
+ * or #MSCAB_COMP_LZX
+ */
+#define MSCABD_COMP_METHOD(comp_type) ((comp_type) & 0x0F)
+/**
+ * Returns the compression level used by a folder.
+ *
+ * @param comp_type a mscabd_folder::comp_type value
+ * @return the compression level. This is only defined by LZX and Quantum
+ * compression
+ */
+#define MSCABD_COMP_LEVEL(comp_type) (((comp_type) >> 8) & 0x1F)
+
+/** Compression mode: no compression. */
+#define MSCAB_COMP_NONE (0)
+/** Compression mode: MSZIP (deflate) compression. */
+#define MSCAB_COMP_MSZIP (1)
+/** Compression mode: Quantum compression */
+#define MSCAB_COMP_QUANTUM (2)
+/** Compression mode: LZX compression */
+#define MSCAB_COMP_LZX (3)
+
+/**
+ * A structure which represents a single file in a cabinet or cabinet set.
+ *
+ * All fields are READ ONLY.
+ */
+struct mscabd_file {
+ /**
+ * The next file in the cabinet or cabinet set, or NULL if this is the
+ * final file.
+ */
+ struct mscabd_file *next;
+
+ /**
+ * The filename of the file.
+ *
+ * A null terminated string of up to 255 bytes in length, it may be in
+ * either ISO-8859-1 or UTF8 format, depending on the file attributes.
+ *
+ * @see attribs
+ */
+ char *filename;
+
+ /** The uncompressed length of the file, in bytes. */
+ unsigned int length;
+
+ /**
+ * File attributes.
+ *
+ * The following attributes are defined:
+ * - #MSCAB_ATTRIB_RDONLY indicates the file is write protected.
+ * - #MSCAB_ATTRIB_HIDDEN indicates the file is hidden.
+ * - #MSCAB_ATTRIB_SYSTEM indicates the file is a operating system file.
+ * - #MSCAB_ATTRIB_ARCH indicates the file is "archived".
+ * - #MSCAB_ATTRIB_EXEC indicates the file is an executable program.
+ * - #MSCAB_ATTRIB_UTF_NAME indicates the filename is in UTF8 format rather
+ * than ISO-8859-1.
+ */
+ int attribs;
+
+ /** File's last modified time, hour field. */
+ char time_h;
+ /** File's last modified time, minute field. */
+ char time_m;
+ /** File's last modified time, second field. */
+ char time_s;
+
+ /** File's last modified date, day field. */
+ char date_d;
+ /** File's last modified date, month field. */
+ char date_m;
+ /** File's last modified date, year field. */
+ int date_y;
+
+ /** A pointer to the folder that contains this file. */
+ struct mscabd_folder *folder;
+
+ /** The uncompressed offset of this file in its folder. */
+ unsigned int offset;
+};
+
+/** mscabd_file::attribs attribute: file is read-only. */
+#define MSCAB_ATTRIB_RDONLY (0x01)
+/** mscabd_file::attribs attribute: file is hidden. */
+#define MSCAB_ATTRIB_HIDDEN (0x02)
+/** mscabd_file::attribs attribute: file is an operating system file. */
+#define MSCAB_ATTRIB_SYSTEM (0x04)
+/** mscabd_file::attribs attribute: file is "archived". */
+#define MSCAB_ATTRIB_ARCH (0x20)
+/** mscabd_file::attribs attribute: file is an executable program. */
+#define MSCAB_ATTRIB_EXEC (0x40)
+/** mscabd_file::attribs attribute: filename is UTF8, not ISO-8859-1. */
+#define MSCAB_ATTRIB_UTF_NAME (0x80)
+
+/** mscab_decompressor::set_param() parameter: search buffer size. */
+#define MSCABD_PARAM_SEARCHBUF (0)
+/** mscab_decompressor::set_param() parameter: repair MS-ZIP streams? */
+#define MSCABD_PARAM_FIXMSZIP (1)
+/** mscab_decompressor::set_param() parameter: size of decompression buffer */
+#define MSCABD_PARAM_DECOMPBUF (2)
+
+/** TODO */
+struct mscab_compressor {
+ int dummy;
+};
+
+/**
+ * A decompressor for .CAB (Microsoft Cabinet) files
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_cab_decompressor(), mspack_destroy_cab_decompressor()
+ */
+struct mscab_decompressor {
+ /**
+ * Opens a cabinet file and reads its contents.
+ *
+ * If the file opened is a valid cabinet file, all headers will be read
+ * and a mscabd_cabinet structure will be returned, with a full list of
+ * folders and files.
+ *
+ * In the case of an error occuring, NULL is returned and the error code
+ * is available from last_error().
+ *
+ * The filename pointer should be considered "in use" until close() is
+ * called on the cabinet.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param filename the filename of the cabinet file. This is passed
+ * directly to mspack_system::open().
+ * @return a pointer to a mscabd_cabinet structure, or NULL on failure
+ * @see close(), search(), last_error()
+ */
+ struct mscabd_cabinet * (*open) (struct mscab_decompressor *self,
+ const char *filename);
+
+ /**
+ * Closes a previously opened cabinet or cabinet set.
+ *
+ * This closes a cabinet, all cabinets associated with it via the
+ * mscabd_cabinet::next, mscabd_cabinet::prevcab and
+ * mscabd_cabinet::nextcab pointers, and all folders and files. All
+ * memory used by these entities is freed.
+ *
+ * The cabinet pointer is now invalid and cannot be used again. All
+ * mscabd_folder and mscabd_file pointers from that cabinet or cabinet
+ * set are also now invalid, and cannot be used again.
+ *
+ * If the cabinet pointer given was created using search(), it MUST be
+ * the cabinet pointer returned by search() and not one of the later
+ * cabinet pointers further along the mscabd_cabinet::next chain.
+
+ * If extra cabinets have been added using append() or prepend(), these
+ * will all be freed, even if the cabinet pointer given is not the first
+ * cabinet in the set. Do NOT close() more than one cabinet in the set.
+ *
+ * The mscabd_cabinet::filename is not freed by the library, as it is
+ * not allocated by the library. The caller should free this itself if
+ * necessary, before it is lost forever.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param cab the cabinet to close
+ * @see open(), search(), append(), prepend()
+ */
+ void (*close)(struct mscab_decompressor *self,
+ struct mscabd_cabinet *cab);
+
+ /**
+ * Searches a regular file for embedded cabinets.
+ *
+ * This opens a normal file with the given filename and will search the
+ * entire file for embedded cabinet files
+ *
+ * If any cabinets are found, the equivalent of open() is called on each
+ * potential cabinet file at the offset it was found. All successfully
+ * open()ed cabinets are kept in a list.
+ *
+ * The first cabinet found will be returned directly as the result of
+ * this method. Any further cabinets found will be chained in a list
+ * using the mscabd_cabinet::next field.
+ *
+ * In the case of an error occuring anywhere other than the simulated
+ * open(), NULL is returned and the error code is available from
+ * last_error().
+ *
+ * If no error occurs, but no cabinets can be found in the file, NULL is
+ * returned and last_error() returns MSPACK_ERR_OK.
+ *
+ * The filename pointer should be considered in use until close() is
+ * called on the cabinet.
+ *
+ * close() should only be called on the result of search(), not on any
+ * subsequent cabinets in the mscabd_cabinet::next chain.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param filename the filename of the file to search for cabinets. This
+ * is passed directly to mspack_system::open().
+ * @return a pointer to a mscabd_cabinet structure, or NULL
+ * @see close(), open(), last_error()
+ */
+ struct mscabd_cabinet * (*search) (struct mscab_decompressor *self,
+ const char *filename);
+
+ /**
+ * Appends one mscabd_cabinet to another, forming or extending a cabinet
+ * set.
+ *
+ * This will attempt to append one cabinet to another such that
+ * <tt>(cab->nextcab == nextcab) && (nextcab->prevcab == cab)</tt> and
+ * any folders split between the two cabinets are merged.
+ *
+ * The cabinets MUST be part of a cabinet set -- a cabinet set is a
+ * cabinet that spans more than one physical cabinet file on disk -- and
+ * must be appropriately matched.
+ *
+ * It can be determined if a cabinet has further parts to load by
+ * examining the mscabd_cabinet::flags field:
+ *
+ * - if <tt>(flags & MSCAB_HDR_PREVCAB)</tt> is non-zero, there is a
+ * predecessor cabinet to open() and prepend(). Its MS-DOS
+ * case-insensitive filename is mscabd_cabinet::prevname
+ * - if <tt>(flags & MSCAB_HDR_NEXTCAB)</tt> is non-zero, there is a
+ * successor cabinet to open() and append(). Its MS-DOS case-insensitive
+ * filename is mscabd_cabinet::nextname
+ *
+ * If the cabinets do not match, an error code will be returned. Neither
+ * cabinet has been altered, and both should be closed seperately.
+ *
+ * Files and folders in a cabinet set are a single entity. All cabinets
+ * in a set use the same file list, which is updated as cabinets in the
+ * set are added. All pointers to mscabd_folder and mscabd_file
+ * structures in either cabinet must be discarded and re-obtained after
+ * merging.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param cab the cabinet which will be appended to,
+ * predecessor of nextcab
+ * @param nextcab the cabinet which will be appended,
+ * successor of cab
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see prepend(), open(), close()
+ */
+ int (*append) (struct mscab_decompressor *self,
+ struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *nextcab);
+
+ /**
+ * Prepends one mscabd_cabinet to another, forming or extending a
+ * cabinet set.
+ *
+ * This will attempt to prepend one cabinet to another, such that
+ * <tt>(cab->prevcab == prevcab) && (prevcab->nextcab == cab)</tt>. In
+ * all other respects, it is identical to append(). See append() for the
+ * full documentation.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param cab the cabinet which will be prepended to,
+ * successor of prevcab
+ * @param prevcab the cabinet which will be prepended,
+ * predecessor of cab
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see append(), open(), close()
+ */
+ int (*prepend) (struct mscab_decompressor *self,
+ struct mscabd_cabinet *cab,
+ struct mscabd_cabinet *prevcab);
+
+ /**
+ * Extracts a file from a cabinet or cabinet set.
+ *
+ * This extracts a compressed file in a cabinet and writes it to the given
+ * filename.
+ *
+ * The MS-DOS filename of the file, mscabd_file::filename, is NOT USED
+ * by extract(). The caller must examine this MS-DOS filename, copy and
+ * change it as necessary, create directories as necessary, and provide
+ * the correct filename as a parameter, which will be passed unchanged
+ * to the decompressor's mspack_system::open()
+ *
+ * If the file belongs to a split folder in a multi-part cabinet set,
+ * and not enough parts of the cabinet set have been loaded and appended
+ * or prepended, an error will be returned immediately.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param file the file to be decompressed
+ * @param filename the filename of the file being written to
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*extract)(struct mscab_decompressor *self,
+ struct mscabd_file *file,
+ const char *filename);
+
+ /**
+ * Sets a CAB decompression engine parameter.
+ *
+ * The following parameters are defined:
+ * - #MSCABD_PARAM_SEARCHBUF: How many bytes should be allocated as a
+ * buffer when using search()? The minimum value is 4. The default
+ * value is 32768.
+ * - #MSCABD_PARAM_FIXMSZIP: If non-zero, extract() will ignore bad
+ * checksums and recover from decompression errors in MS-ZIP
+ * compressed folders. The default value is 0 (don't recover).
+ * - #MSCABD_PARAM_DECOMPBUF: How many bytes should be used as an input
+ * bit buffer by decompressors? The minimum value is 4. The default
+ * value is 4096.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @param param the parameter to set
+ * @param value the value to set the parameter to
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+ * is a problem with either parameter or value.
+ * @see search(), extract()
+ */
+ int (*set_param)(struct mscab_decompressor *self,
+ int param,
+ int value);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * This is useful for open() and search(), which do not return an error
+ * code directly.
+ *
+ * @param self a self-referential pointer to the mscab_decompressor
+ * instance being called
+ * @return the most recent error code
+ * @see open(), search()
+ */
+ int (*last_error)(struct mscab_decompressor *self);
+};
+
+/* --- support for .CHM (HTMLHelp) file format ----------------------------- */
+
+/**
+ * A structure which represents a file to be placed in a CHM helpfile.
+ *
+ * A contiguous array of these structures should be passed to
+ * mschm_compressor::generate(). The array list is terminated with an
+ * entry whose mschmc_file::section field is set to #MSCHMC_ENDLIST, the
+ * other fields in this entry are ignored.
+ */
+struct mschmc_file {
+ /** One of #MSCHMC_ENDLIST, #MSCHMC_UNCOMP or #MSCHMC_MSCOMP. */
+ int section;
+
+ /** The filename of the source file that will be added to the CHM. This
+ * is passed directly to mspack_system::open(). */
+ const char *filename;
+
+ /** The full path and filename of the file within the CHM helpfile, a
+ * UTF-1 encoded null-terminated string. */
+ char *chm_filename;
+
+ /** The length of the file, in bytes. This will be adhered to strictly
+ * and a read error will be issued if this many bytes cannot be read
+ * from the real file at CHM generation time. */
+ off_t length;
+};
+
+/**
+ * A structure which represents a section of a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ *
+ * Not used directly, but used as a generic base type for
+ * mschmd_sec_uncompressed and mschmd_sec_mscompressed.
+ */
+struct mschmd_section {
+ /** A pointer to the CHM helpfile that contains this section. */
+ struct mschmd_header *chm;
+
+ /**
+ * The section ID. Either 0 for the uncompressed section
+ * mschmd_sec_uncompressed, or 1 for the LZX compressed section
+ * mschmd_sec_mscompressed. No other section IDs are known.
+ */
+ unsigned int id;
+};
+
+/**
+ * A structure which represents the uncompressed section of a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ */
+struct mschmd_sec_uncompressed {
+ /** Generic section data. */
+ struct mschmd_section base;
+
+ /** The file offset of where this section begins in the CHM helpfile. */
+ off_t offset;
+};
+
+/**
+ * A structure which represents the LZX compressed section of a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ */
+struct mschmd_sec_mscompressed {
+ /** Generic section data. */
+ struct mschmd_section base;
+
+ /** A pointer to the meta-file which represents all LZX compressed data. */
+ struct mschmd_file *content;
+
+ /** A pointer to the file which contains the LZX control data. */
+ struct mschmd_file *control;
+
+ /** A pointer to the file which contains the LZX reset table. */
+ struct mschmd_file *rtable;
+
+ /** A pointer to the file which contains the LZX span information.
+ * Available only in CHM decoder version 2 and above.
+ */
+ struct mschmd_file *spaninfo;
+};
+
+/**
+ * A structure which represents a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ */
+struct mschmd_header {
+ /** The version of the CHM file format used in this file. */
+ unsigned int version;
+
+ /**
+ * The "timestamp" of the CHM helpfile.
+ *
+ * It is the lower 32 bits of a 64-bit value representing the number of
+ * centiseconds since 1601-01-01 00:00:00 UTC, plus 42. It is not useful
+ * as a timestamp, but it is useful as a semi-unique ID.
+ */
+ unsigned int timestamp;
+
+ /**
+ * The default Language and Country ID (LCID) of the user who ran the
+ * HTMLHelp Compiler. This is not the language of the CHM file itself.
+ */
+ unsigned int language;
+
+ /**
+ * The filename of the CHM helpfile. This is given by the library user
+ * and may be in any format.
+ */
+ const char *filename;
+
+ /** The length of the CHM helpfile, in bytes. */
+ off_t length;
+
+ /** A list of all non-system files in the CHM helpfile. */
+ struct mschmd_file *files;
+
+ /**
+ * A list of all system files in the CHM helpfile.
+ *
+ * System files are files which begin with "::". They are meta-files
+ * generated by the CHM creation process.
+ */
+ struct mschmd_file *sysfiles;
+
+ /** The section 0 (uncompressed) data in this CHM helpfile. */
+ struct mschmd_sec_uncompressed sec0;
+
+ /** The section 1 (MSCompressed) data in this CHM helpfile. */
+ struct mschmd_sec_mscompressed sec1;
+
+ /** The file offset of the first PMGL/PMGI directory chunk. */
+ off_t dir_offset;
+
+ /** The number of PMGL/PMGI directory chunks in this CHM helpfile. */
+ unsigned int num_chunks;
+
+ /** The size of each PMGL/PMGI chunk, in bytes. */
+ unsigned int chunk_size;
+
+ /** The "density" of the quick-reference section in PMGL/PMGI chunks. */
+ unsigned int density;
+
+ /** The depth of the index tree.
+ *
+ * - if 1, there are no PMGI chunks, only PMGL chunks.
+ * - if 2, there is 1 PMGI chunk. All chunk indices point to PMGL chunks.
+ * - if 3, the root PMGI chunk points to secondary PMGI chunks, which in
+ * turn point to PMGL chunks.
+ * - and so on...
+ */
+ unsigned int depth;
+
+ /**
+ * The number of the root PMGI chunk.
+ *
+ * If there is no index in the CHM helpfile, this will be 0xFFFFFFFF.
+ */
+ unsigned int index_root;
+
+ /**
+ * The number of the first PMGL chunk. Usually zero.
+ * Available only in CHM decoder version 2 and above.
+ */
+ unsigned int first_pmgl;
+
+ /**
+ * The number of the last PMGL chunk. Usually num_chunks-1.
+ * Available only in CHM decoder version 2 and above.
+ */
+ unsigned int last_pmgl;
+
+ /**
+ * A cache of loaded chunks, filled in by mschm_decoder::fast_find().
+ * Available only in CHM decoder version 2 and above.
+ */
+ unsigned char **chunk_cache;
+};
+
+/**
+ * A structure which represents a file stored in a CHM helpfile.
+ *
+ * All fields are READ ONLY.
+ */
+struct mschmd_file {
+ /**
+ * A pointer to the next file in the list, or NULL if this is the final
+ * file.
+ */
+ struct mschmd_file *next;
+
+ /**
+ * A pointer to the section that this file is located in. Indirectly,
+ * it also points to the CHM helpfile the file is located in.
+ */
+ struct mschmd_section *section;
+
+ /** The offset within the section data that this file is located at. */
+ off_t offset;
+
+ /** The length of this file, in bytes */
+ off_t length;
+
+ /** The filename of this file -- a null terminated string in UTF-8. */
+ char *filename;
+};
+
+/** mschmc_file::section value: end of CHM file list */
+#define MSCHMC_ENDLIST (0)
+/** mschmc_file::section value: this file is in the Uncompressed section */
+#define MSCHMC_UNCOMP (1)
+/** mschmc_file::section value: this file is in the MSCompressed section */
+#define MSCHMC_MSCOMP (2)
+
+/** mschm_compressor::set_param() parameter: "timestamp" header */
+#define MSCHMC_PARAM_TIMESTAMP (0)
+/** mschm_compressor::set_param() parameter: "language" header */
+#define MSCHMC_PARAM_LANGUAGE (1)
+/** mschm_compressor::set_param() parameter: LZX window size */
+#define MSCHMC_PARAM_LZXWINDOW (2)
+/** mschm_compressor::set_param() parameter: intra-chunk quickref density */
+#define MSCHMC_PARAM_DENSITY (3)
+/** mschm_compressor::set_param() parameter: whether to create indices */
+#define MSCHMC_PARAM_INDEX (4)
+
+/**
+ * A compressor for .CHM (Microsoft HTMLHelp) files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_chm_compressor(), mspack_destroy_chm_compressor()
+ */
+struct mschm_compressor {
+ /**
+ * Generates a CHM help file.
+ *
+ * The help file will contain up to two sections, an Uncompressed
+ * section and potentially an MSCompressed (LZX compressed)
+ * section.
+ *
+ * While the contents listing of a CHM file is always in lexical order,
+ * the file list passed in will be taken as the correct order for files
+ * within the sections. It is in your interest to place similar files
+ * together for better compression.
+ *
+ * There are two modes of generation, to use a temporary file or not to
+ * use one. See use_temporary_file() for the behaviour of generate() in
+ * these two different modes.
+ *
+ * @param self a self-referential pointer to the mschm_compressor
+ * instance being called
+ * @param file_list an array of mschmc_file structures, terminated
+ * with an entry whose mschmc_file::section field is
+ * #MSCHMC_ENDLIST. The order of the list is
+ * preserved within each section. The length of any
+ * mschmc_file::chm_filename string cannot exceed
+ * roughly 4096 bytes. Each source file must be able
+ * to supply as many bytes as given in the
+ * mschmc_file::length field.
+ * @param output_file the file to write the generated CHM helpfile to.
+ * This is passed directly to mspack_system::open()
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see use_temporary_file() set_param()
+ */
+ int (*generate)(struct mschm_compressor *self,
+ struct mschmc_file file_list[],
+ const char *output_file);
+
+ /**
+ * Specifies whether a temporary file is used during CHM generation.
+ *
+ * The CHM file format includes data about the compressed section (such
+ * as its overall size) that is stored in the output CHM file prior to
+ * the compressed section itself. This unavoidably requires that the
+ * compressed section has to be generated, before these details can be
+ * set. There are several ways this can be handled. Firstly, the
+ * compressed section could be generated entirely in memory before
+ * writing any of the output CHM file. This approach is not used in
+ * libmspack, as the compressed section can exceed the addressable
+ * memory space on most architectures.
+ *
+ * libmspack has two options, either to write these unknowable sections
+ * with blank data, generate the compressed section, then re-open the
+ * output file for update once the compressed section has been
+ * completed, or to write the compressed section to a temporary file,
+ * then write the entire output file at once, performing a simple
+ * file-to-file copy for the compressed section.
+ *
+ * The simple solution of buffering the entire compressed section in
+ * memory can still be used, if desired. As the temporary file's
+ * filename is passed directly to mspack_system::open(), it is possible
+ * for a custom mspack_system implementation to hold this file in memory,
+ * without writing to a disk.
+ *
+ * If a temporary file is set, generate() performs the following
+ * sequence of events: the temporary file is opened for writing, the
+ * compression algorithm writes to the temporary file, the temporary
+ * file is closed. Then the output file is opened for writing and the
+ * temporary file is re-opened for reading. The output file is written
+ * and the temporary file is read from. Both files are then closed. The
+ * temporary file itself is not deleted. If that is desired, the
+ * temporary file should be deleted after the completion of generate(),
+ * if it exists.
+ *
+ * If a temporary file is set not to be used, generate() performs the
+ * following sequence of events: the output file is opened for writing,
+ * then it is written and closed. The output file is then re-opened for
+ * update, the appropriate sections are seek()ed to and re-written, then
+ * the output file is closed.
+ *
+ * @param self a self-referential pointer to the
+ * mschm_compressor instance being called
+ * @param use_temp_file non-zero if the temporary file should be used,
+ * zero if the temporary file should not be used.
+ * @param temp_file a file to temporarily write compressed data to,
+ * before opening it for reading and copying the
+ * contents to the output file. This is passed
+ * directly to mspack_system::open().
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see generate()
+ */
+ int (*use_temporary_file)(struct mschm_compressor *self,
+ int use_temp_file,
+ const char *temp_file);
+ /**
+ * Sets a CHM compression engine parameter.
+ *
+ * The following parameters are defined:
+
+ * - #MSCHMC_PARAM_TIMESTAMP: Sets the "timestamp" of the CHM file
+ * generated. This is not a timestamp, see mschmd_header::timestamp
+ * for a description. If this timestamp is 0, generate() will use its
+ * own algorithm for making a unique ID, based on the lengths and
+ * names of files in the CHM itself. Defaults to 0, any value between
+ * 0 and (2^32)-1 is valid.
+ * - #MSCHMC_PARAM_LANGUAGE: Sets the "language" of the CHM file
+ * generated. This is not the language used in the CHM file, but the
+ * language setting of the user who ran the HTMLHelp compiler. It
+ * defaults to 0x0409. The valid range is between 0x0000 and 0x7F7F.
+ * - #MSCHMC_PARAM_LZXWINDOW: Sets the size of the LZX history window,
+ * which is also the interval at which the compressed data stream can be
+ * randomly accessed. The value is not a size in bytes, but a power of
+ * two. The default value is 16 (which makes the window 2^16 bytes, or
+ * 64 kilobytes), the valid range is from 15 (32 kilobytes) to 21 (2
+ * megabytes).
+ * - #MSCHMC_PARAM_DENSITY: Sets the "density" of quick reference
+ * entries stored at the end of directory listing chunk. Each chunk is
+ * 4096 bytes in size, and contains as many file entries as there is
+ * room for. At the other end of the chunk, a list of "quick reference"
+ * pointers is included. The offset of every 'N'th file entry is given a
+ * quick reference, where N = (2^density) + 1. The default density is
+ * 2. The smallest density is 0 (N=2), the maximum is 10 (N=1025). As
+ * each file entry requires at least 5 bytes, the maximum number of
+ * entries in a single chunk is roughly 800, so the maximum value 10
+ * can be used to indicate there are no quickrefs at all.
+ * - #MSCHMC_PARAM_INDEX: Sets whether or not to include quick lookup
+ * index chunk(s), in addition to normal directory listing chunks. A
+ * value of zero means no index chunks will be created, a non-zero value
+ * means index chunks will be created. The default is zero, "don't
+ * create an index".
+ *
+ * @param self a self-referential pointer to the mschm_compressor
+ * instance being called
+ * @param param the parameter to set
+ * @param value the value to set the parameter to
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+ * is a problem with either parameter or value.
+ * @see generate()
+ */
+ int (*set_param)(struct mschm_compressor *self,
+ int param,
+ unsigned int value);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * @param self a self-referential pointer to the mschm_compressor
+ * instance being called
+ * @return the most recent error code
+ * @see set_param(), generate()
+ */
+ int (*last_error)(struct mschm_compressor *self);
+};
+
+/**
+ * A decompressor for .CHM (Microsoft HTMLHelp) files
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_chm_decompressor(), mspack_destroy_chm_decompressor()
+ */
+struct mschm_decompressor {
+ /**
+ * Opens a CHM helpfile and reads its contents.
+ *
+ * If the file opened is a valid CHM helpfile, all headers will be read
+ * and a mschmd_header structure will be returned, with a full list of
+ * files.
+ *
+ * In the case of an error occuring, NULL is returned and the error code
+ * is available from last_error().
+ *
+ * The filename pointer should be considered "in use" until close() is
+ * called on the CHM helpfile.
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @param filename the filename of the CHM helpfile. This is passed
+ * directly to mspack_system::open().
+ * @return a pointer to a mschmd_header structure, or NULL on failure
+ * @see close()
+ */
+ struct mschmd_header *(*open)(struct mschm_decompressor *self,
+ const char *filename);
+
+ /**
+ * Closes a previously opened CHM helpfile.
+ *
+ * This closes a CHM helpfile, frees the mschmd_header and all
+ * mschmd_file structures associated with it (if any). This works on
+ * both helpfiles opened with open() and helpfiles opened with
+ * fast_open().
+ *
+ * The CHM header pointer is now invalid and cannot be used again. All
+ * mschmd_file pointers referencing that CHM are also now invalid, and
+ * cannot be used again.
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @param chm the CHM helpfile to close
+ * @see open(), fast_open()
+ */
+ void (*close)(struct mschm_decompressor *self,
+ struct mschmd_header *chm);
+
+ /**
+ * Extracts a file from a CHM helpfile.
+ *
+ * This extracts a file from a CHM helpfile and writes it to the given
+ * filename. The filename of the file, mscabd_file::filename, is not
+ * used by extract(), but can be used by the caller as a guide for
+ * constructing an appropriate filename.
+ *
+ * This method works both with files found in the mschmd_header::files
+ * and mschmd_header::sysfiles list and mschmd_file structures generated
+ * on the fly by fast_find().
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @param file the file to be decompressed
+ * @param filename the filename of the file being written to
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*extract)(struct mschm_decompressor *self,
+ struct mschmd_file *file,
+ const char *filename);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * This is useful for open() and fast_open(), which do not return an
+ * error code directly.
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @return the most recent error code
+ * @see open(), extract()
+ */
+ int (*last_error)(struct mschm_decompressor *self);
+
+ /**
+ * Opens a CHM helpfile quickly.
+ *
+ * If the file opened is a valid CHM helpfile, only essential headers
+ * will be read. A mschmd_header structure will be still be returned, as
+ * with open(), but the mschmd_header::files field will be NULL. No
+ * files details will be automatically read. The fast_find() method
+ * must be used to obtain file details.
+ *
+ * In the case of an error occuring, NULL is returned and the error code
+ * is available from last_error().
+ *
+ * The filename pointer should be considered "in use" until close() is
+ * called on the CHM helpfile.
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @param filename the filename of the CHM helpfile. This is passed
+ * directly to mspack_system::open().
+ * @return a pointer to a mschmd_header structure, or NULL on failure
+ * @see open(), close(), fast_find(), extract()
+ */
+ struct mschmd_header *(*fast_open)(struct mschm_decompressor *self,
+ const char *filename);
+
+ /**
+ * Finds file details quickly.
+ *
+ * Instead of reading all CHM helpfile headers and building a list of
+ * files, fast_open() and fast_find() are intended for finding file
+ * details only when they are needed. The CHM file format includes an
+ * on-disk file index to allow this.
+ *
+ * Given a case-sensitive filename, fast_find() will search the on-disk
+ * index for that file.
+ *
+ * If the file was found, the caller-provided mschmd_file structure will
+ * be filled out like so:
+ * - section: the correct value for the found file
+ * - offset: the correct value for the found file
+ * - length: the correct value for the found file
+ * - all other structure elements: NULL or 0
+ *
+ * If the file was not found, MSPACK_ERR_OK will still be returned as the
+ * result, but the caller-provided structure will be filled out like so:
+ * - section: NULL
+ * - offset: 0
+ * - length: 0
+ * - all other structure elements: NULL or 0
+ *
+ * This method is intended to be used in conjunction with CHM helpfiles
+ * opened with fast_open(), but it also works with helpfiles opened
+ * using the regular open().
+ *
+ * @param self a self-referential pointer to the mschm_decompressor
+ * instance being called
+ * @param chm the CHM helpfile to search for the file
+ * @param filename the filename of the file to search for
+ * @param f_ptr a pointer to a caller-provded mschmd_file structure
+ * @param f_size <tt>sizeof(struct mschmd_file)</tt>
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see open(), close(), fast_find(), extract()
+ */
+ int (*fast_find)(struct mschm_decompressor *self,
+ struct mschmd_header *chm,
+ const char *filename,
+ struct mschmd_file *f_ptr,
+ int f_size);
+};
+
+/* --- support for .LIT (EBook) file format -------------------------------- */
+
+/** TODO */
+struct mslit_compressor {
+ int dummy;
+};
+
+/** TODO */
+struct mslit_decompressor {
+ int dummy;
+};
+
+
+/* --- support for .HLP (MS Help) file format ------------------------------ */
+
+/** TODO */
+struct mshlp_compressor {
+ int dummy;
+};
+
+/** TODO */
+struct mshlp_decompressor {
+ int dummy;
+};
+
+
+/* --- support for SZDD file format ---------------------------------------- */
+
+/** msszdd_compressor::set_param() parameter: the missing character */
+#define MSSZDDC_PARAM_MISSINGCHAR (0)
+
+/** msszddd_header::format value - a regular SZDD file */
+#define MSSZDD_FMT_NORMAL (0)
+
+/** msszddd_header::format value - a special QBasic SZDD file */
+#define MSSZDD_FMT_QBASIC (1)
+
+/**
+ * A structure which represents an SZDD compressed file.
+ *
+ * All fields are READ ONLY.
+ */
+struct msszddd_header {
+ /** The file format; either #MSSZDD_FMT_NORMAL or #MSSZDD_FMT_QBASIC */
+ int format;
+
+ /** The amount of data in the SZDD file once uncompressed. */
+ off_t length;
+
+ /**
+ * The last character in the filename, traditionally replaced with an
+ * underscore to show the file is compressed. The null character is used
+ * to show that this character has not been stored (e.g. because the
+ * filename is not known). Generally, only characters that may appear in
+ * an MS-DOS filename (except ".") are valid.
+ */
+ char missing_char;
+};
+
+/**
+ * A compressor for the SZDD file format.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_szdd_compressor(), mspack_destroy_szdd_compressor()
+ */
+struct msszdd_compressor {
+ /**
+ * Reads an input file and creates a compressed output file in the
+ * SZDD compressed file format. The SZDD compression format is quick
+ * but gives poor compression. It is possible for the compressed output
+ * file to be larger than the input file.
+ *
+ * Conventionally, SZDD compressed files have the final character in
+ * their filename replaced with an underscore, to show they are
+ * compressed. The missing character is stored in the compressed file
+ * itself. This is due to the restricted filename conventions of MS-DOS,
+ * most operating systems, such as UNIX, simply append another file
+ * extension to the existing filename. As mspack does not deal with
+ * filenames, this is left up to you. If you wish to set the missing
+ * character stored in the file header, use set_param() with the
+ * #MSSZDDC_PARAM_MISSINGCHAR parameter.
+ *
+ * "Stream" compression (where the length of the input data is not
+ * known) is not possible. The length of the input data is stored in the
+ * header of the SZDD file and must therefore be known before any data
+ * is compressed. Due to technical limitations of the file format, the
+ * maximum size of uncompressed file that will be accepted is 2147483647
+ * bytes.
+ *
+ * @param self a self-referential pointer to the msszdd_compressor
+ * instance being called
+ * @param input the name of the file to compressed. This is passed
+ * passed directly to mspack_system::open()
+ * @param output the name of the file to write compressed data to.
+ * This is passed directly to mspack_system::open().
+ * @param length the length of the uncompressed file, or -1 to indicate
+ * that this should be determined automatically by using
+ * mspack_system::seek() on the input file.
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see set_param()
+ */
+ int (*compress)(struct msszdd_compressor *self,
+ const char *input,
+ const char *output,
+ off_t length);
+
+ /**
+ * Sets an SZDD compression engine parameter.
+ *
+ * The following parameters are defined:
+
+ * - #MSSZDDC_PARAM_CHARACTER: the "missing character", the last character
+ * in the uncompressed file's filename, which is traditionally replaced
+ * with an underscore to show the file is compressed. Traditionally,
+ * this can only be a character that is a valid part of an MS-DOS,
+ * filename, but libmspack permits any character between 0x00 and 0xFF
+ * to be stored. 0x00 is the default, and it represents "no character
+ * stored".
+ *
+ * @param self a self-referential pointer to the msszdd_compressor
+ * instance being called
+ * @param param the parameter to set
+ * @param value the value to set the parameter to
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+ * is a problem with either parameter or value.
+ * @see compress()
+ */
+ int (*set_param)(struct msszdd_compressor *self,
+ int param,
+ unsigned int value);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * @param self a self-referential pointer to the msszdd_compressor
+ * instance being called
+ * @return the most recent error code
+ * @see compress()
+ */
+ int (*last_error)(struct mschm_decompressor *self);
+};
+
+/**
+ * A decompressor for SZDD compressed files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_szdd_decompressor(), mspack_destroy_szdd_decompressor()
+ */
+struct msszdd_decompressor {
+ /**
+ * Opens a SZDD file and reads the header.
+ *
+ * If the file opened is a valid SZDD file, all headers will be read and
+ * a msszddd_header structure will be returned.
+ *
+ * In the case of an error occuring, NULL is returned and the error code
+ * is available from last_error().
+ *
+ * The filename pointer should be considered "in use" until close() is
+ * called on the SZDD file.
+ *
+ * @param self a self-referential pointer to the msszdd_decompressor
+ * instance being called
+ * @param filename the filename of the SZDD compressed file. This is
+ * passed directly to mspack_system::open().
+ * @return a pointer to a msszddd_header structure, or NULL on failure
+ * @see close()
+ */
+ struct msszddd_header *(*open)(struct msszdd_decompressor *self,
+ const char *filename);
+
+ /**
+ * Closes a previously opened SZDD file.
+ *
+ * This closes a SZDD file and frees the msszddd_header associated with
+ * it.
+ *
+ * The SZDD header pointer is now invalid and cannot be used again.
+ *
+ * @param self a self-referential pointer to the msszdd_decompressor
+ * instance being called
+ * @param szdd the SZDD file to close
+ * @see open()
+ */
+ void (*close)(struct msszdd_decompressor *self,
+ struct msszddd_header *szdd);
+
+ /**
+ * Extracts the compressed data from a SZDD file.
+ *
+ * This decompresses the compressed SZDD data stream and writes it to
+ * an output file.
+ *
+ * @param self a self-referential pointer to the msszdd_decompressor
+ * instance being called
+ * @param szdd the SZDD file to extract data from
+ * @param filename the filename to write the decompressed data to. This
+ * is passed directly to mspack_system::open().
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*extract)(struct msszdd_decompressor *self,
+ struct msszddd_header *szdd,
+ const char *filename);
+
+ /**
+ * Decompresses an SZDD file to an output file in one step.
+ *
+ * This opens an SZDD file as input, reads the header, then decompresses
+ * the compressed data immediately to an output file, finally closing
+ * both the input and output file. It is more convenient to use than
+ * open() then extract() then close(), if you do not need to know the
+ * SZDD output size or missing character.
+ *
+ * @param self a self-referential pointer to the msszdd_decompressor
+ * instance being called
+ * @param input the filename of the input SZDD file. This is passed
+ * directly to mspack_system::open().
+ * @param output the filename to write the decompressed data to. This
+ * is passed directly to mspack_system::open().
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*decompress)(struct msszdd_decompressor *self,
+ const char *input,
+ const char *output);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * This is useful for open() which does not return an
+ * error code directly.
+ *
+ * @param self a self-referential pointer to the msszdd_decompressor
+ * instance being called
+ * @return the most recent error code
+ * @see open(), extract(), decompress()
+ */
+ int (*last_error)(struct msszdd_decompressor *self);
+};
+
+/* --- support for KWAJ file format ---------------------------------------- */
+
+/** mskwaj_compressor::set_param() parameter: compression type */
+#define MSKWAJC_PARAM_COMP_TYPE (0)
+
+/** mskwaj_compressor::set_param() parameter: include the length of the
+ * uncompressed file in the header?
+ */
+#define MSKWAJC_PARAM_INCLUDE_LENGTH (1)
+
+/** KWAJ compression type: no compression. */
+#define MSKWAJ_COMP_NONE (0)
+/** KWAJ compression type: no compression, 0xFF XOR "encryption". */
+#define MSKWAJ_COMP_XOR (1)
+/** KWAJ compression type: LZSS (same method as SZDD) */
+#define MSKWAJ_COMP_SZDD (2)
+/** KWAJ compression type: LZ+Huffman compression */
+#define MSKWAJ_COMP_LZH (3)
+
+/** KWAJ optional header flag: decompressed file length is included */
+#define MSKWAJ_HDR_HASLENGTH (0x01)
+
+/** KWAJ optional header flag: unknown 2-byte structure is included */
+#define MSKWAJ_HDR_HASUNKNOWN1 (0x02)
+
+/** KWAJ optional header flag: unknown multi-sized structure is included */
+#define MSKWAJ_HDR_HASUNKNOWN2 (0x04)
+
+/** KWAJ optional header flag: file name (no extension) is included */
+#define MSKWAJ_HDR_HASFILENAME (0x08)
+
+/** KWAJ optional header flag: file extension is included */
+#define MSKWAJ_HDR_HASFILEEXT (0x10)
+
+/** KWAJ optional header flag: extra text is included */
+#define MSKWAJ_HDR_HASEXTRATEXT (0x20)
+
+/**
+ * A structure which represents an KWAJ compressed file.
+ *
+ * All fields are READ ONLY.
+ */
+struct mskwajd_header {
+ /** The compression type; should be one of #MSKWAJ_COMP_NONE,
+ * #MSKWAJ_COMP_XOR, #MSKWAJ_COMP_SZDD or #MSKWAJ_COMP_LZH
+ */
+ unsigned short comp_type;
+
+ /** The offset in the file where the compressed data stream begins */
+ off_t data_offset;
+
+ /** Flags indicating which optional headers were included. */
+ int headers;
+
+ /** The amount of uncompressed data in the file, or 0 if not present. */
+ off_t length;
+
+ /** output filename, or NULL if not present */
+ char *filename;
+
+ /** extra uncompressed data (usually text) in the header.
+ * This data can contain nulls so use extra_length to get the size.
+ */
+ char *extra;
+
+ /** length of extra uncompressed data in the header */
+ unsigned short extra_length;
+};
+
+/**
+ * A compressor for the KWAJ file format.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_kwaj_compressor(), mspack_destroy_kwaj_compressor()
+ */
+struct mskwaj_compressor {
+ /**
+ * Reads an input file and creates a compressed output file in the
+ * KWAJ compressed file format. The KWAJ compression format is quick
+ * but gives poor compression. It is possible for the compressed output
+ * file to be larger than the input file.
+ *
+ * @param self a self-referential pointer to the mskwaj_compressor
+ * instance being called
+ * @param input the name of the file to compressed. This is passed
+ * passed directly to mspack_system::open()
+ * @param output the name of the file to write compressed data to.
+ * This is passed directly to mspack_system::open().
+ * @param length the length of the uncompressed file, or -1 to indicate
+ * that this should be determined automatically by using
+ * mspack_system::seek() on the input file.
+ * @return an error code, or MSPACK_ERR_OK if successful
+ * @see set_param()
+ */
+ int (*compress)(struct mskwaj_compressor *self,
+ const char *input,
+ const char *output,
+ off_t length);
+
+ /**
+ * Sets an KWAJ compression engine parameter.
+ *
+ * The following parameters are defined:
+ *
+ * - #MSKWAJC_PARAM_COMP_TYPE: the compression method to use. Must
+ * be one of #MSKWAJC_COMP_NONE, #MSKWAJC_COMP_XOR, #MSKWAJ_COMP_SZDD
+ * or #MSKWAJ_COMP_LZH. The default is #MSKWAJ_COMP_LZH.
+ *
+ * - #MSKWAJC_PARAM_INCLUDE_LENGTH: a boolean; should the compressed
+ * output file should include the uncompressed length of the input
+ * file in the header? This adds 4 bytes to the size of the output
+ * file. A value of zero says "no", non-zero says "yes". The default
+ * is "no".
+ *
+ * @param self a self-referential pointer to the mskwaj_compressor
+ * instance being called
+ * @param param the parameter to set
+ * @param value the value to set the parameter to
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if there
+ * is a problem with either parameter or value.
+ * @see generate()
+ */
+ int (*set_param)(struct mskwaj_compressor *self,
+ int param,
+ unsigned int value);
+
+
+ /**
+ * Sets the original filename of the file before compression,
+ * which will be stored in the header of the output file.
+ *
+ * The filename should be a null-terminated string, it must be an
+ * MS-DOS "8.3" type filename (up to 8 bytes for the filename, then
+ * optionally a "." and up to 3 bytes for a filename extension).
+ *
+ * If NULL is passed as the filename, no filename is included in the
+ * header. This is the default.
+ *
+ * @param self a self-referential pointer to the mskwaj_compressor
+ * instance being called
+ * @param filename the original filename to use
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS if the
+ * filename is too long
+ */
+ int (*set_filename)(struct mskwaj_compressor *self,
+ const char *filename);
+
+ /**
+ * Sets arbitrary data that will be stored in the header of the
+ * output file, uncompressed. It can be up to roughly 64 kilobytes,
+ * as the overall size of the header must not exceed 65535 bytes.
+ * The data can contain null bytes if desired.
+ *
+ * If NULL is passed as the data pointer, or zero is passed as the
+ * length, no extra data is included in the header. This is the
+ * default.
+ *
+ * @param self a self-referential pointer to the mskwaj_compressor
+ * instance being called
+ * @param data a pointer to the data to be stored in the header
+ * @param bytes the length of the data in bytes
+ * @return MSPACK_ERR_OK if all is OK, or MSPACK_ERR_ARGS extra data
+ * is too long
+ */
+ int (*set_extra_data)(struct mskwaj_compressor *self,
+ void *data,
+ size_t bytes);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * @param self a self-referential pointer to the mskwaj_compressor
+ * instance being called
+ * @return the most recent error code
+ * @see compress()
+ */
+ int (*last_error)(struct mschm_decompressor *self);
+};
+
+/**
+ * A decompressor for KWAJ compressed files.
+ *
+ * All fields are READ ONLY.
+ *
+ * @see mspack_create_kwaj_decompressor(), mspack_destroy_kwaj_decompressor()
+ */
+struct mskwaj_decompressor {
+ /**
+ * Opens a KWAJ file and reads the header.
+ *
+ * If the file opened is a valid KWAJ file, all headers will be read and
+ * a mskwajd_header structure will be returned.
+ *
+ * In the case of an error occuring, NULL is returned and the error code
+ * is available from last_error().
+ *
+ * The filename pointer should be considered "in use" until close() is
+ * called on the KWAJ file.
+ *
+ * @param self a self-referential pointer to the mskwaj_decompressor
+ * instance being called
+ * @param filename the filename of the KWAJ compressed file. This is
+ * passed directly to mspack_system::open().
+ * @return a pointer to a mskwajd_header structure, or NULL on failure
+ * @see close()
+ */
+ struct mskwajd_header *(*open)(struct mskwaj_decompressor *self,
+ const char *filename);
+
+ /**
+ * Closes a previously opened KWAJ file.
+ *
+ * This closes a KWAJ file and frees the mskwajd_header associated
+ * with it. The KWAJ header pointer is now invalid and cannot be
+ * used again.
+ *
+ * @param self a self-referential pointer to the mskwaj_decompressor
+ * instance being called
+ * @param kwaj the KWAJ file to close
+ * @see open()
+ */
+ void (*close)(struct mskwaj_decompressor *self,
+ struct mskwajd_header *kwaj);
+
+ /**
+ * Extracts the compressed data from a KWAJ file.
+ *
+ * This decompresses the compressed KWAJ data stream and writes it to
+ * an output file.
+ *
+ * @param self a self-referential pointer to the mskwaj_decompressor
+ * instance being called
+ * @param kwaj the KWAJ file to extract data from
+ * @param filename the filename to write the decompressed data to. This
+ * is passed directly to mspack_system::open().
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*extract)(struct mskwaj_decompressor *self,
+ struct mskwajd_header *kwaj,
+ const char *filename);
+
+ /**
+ * Decompresses an KWAJ file to an output file in one step.
+ *
+ * This opens an KWAJ file as input, reads the header, then decompresses
+ * the compressed data immediately to an output file, finally closing
+ * both the input and output file. It is more convenient to use than
+ * open() then extract() then close(), if you do not need to know the
+ * KWAJ output size or output filename.
+ *
+ * @param self a self-referential pointer to the mskwaj_decompressor
+ * instance being called
+ * @param input the filename of the input KWAJ file. This is passed
+ * directly to mspack_system::open().
+ * @param output the filename to write the decompressed data to. This
+ * is passed directly to mspack_system::open().
+ * @return an error code, or MSPACK_ERR_OK if successful
+ */
+ int (*decompress)(struct mskwaj_decompressor *self,
+ const char *input,
+ const char *output);
+
+ /**
+ * Returns the error code set by the most recently called method.
+ *
+ * This is useful for open() which does not return an
+ * error code directly.
+ *
+ * @param self a self-referential pointer to the mskwaj_decompressor
+ * instance being called
+ * @return the most recent error code
+ * @see open(), search()
+ */
+ int (*last_error)(struct mskwaj_decompressor *self);
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/mszip.h b/rbutil/rbutilqt/mspack/mszip.h
new file mode 100644
index 0000000000..13c9542ee6
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/mszip.h
@@ -0,0 +1,121 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The deflate method was created by Phil Katz. MSZIP is equivalent to the
+ * deflate method.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_MSZIP_H
+#define MSPACK_MSZIP_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* MSZIP (deflate) compression / (inflate) decompression definitions */
+
+#define MSZIP_FRAME_SIZE (32768) /* size of LZ history window */
+#define MSZIP_LITERAL_MAXSYMBOLS (288) /* literal/length huffman tree */
+#define MSZIP_LITERAL_TABLEBITS (9)
+#define MSZIP_DISTANCE_MAXSYMBOLS (32) /* distance huffman tree */
+#define MSZIP_DISTANCE_TABLEBITS (6)
+
+/* if there are less direct lookup entries than symbols, the longer
+ * code pointers will be <= maxsymbols. This must not happen, or we
+ * will decode entries badly */
+#if (1 << MSZIP_LITERAL_TABLEBITS) < (MSZIP_LITERAL_MAXSYMBOLS * 2)
+# define MSZIP_LITERAL_TABLESIZE (MSZIP_LITERAL_MAXSYMBOLS * 4)
+#else
+# define MSZIP_LITERAL_TABLESIZE ((1 << MSZIP_LITERAL_TABLEBITS) + \
+ (MSZIP_LITERAL_MAXSYMBOLS * 2))
+#endif
+
+#if (1 << MSZIP_DISTANCE_TABLEBITS) < (MSZIP_DISTANCE_MAXSYMBOLS * 2)
+# define MSZIP_DISTANCE_TABLESIZE (MSZIP_DISTANCE_MAXSYMBOLS * 4)
+#else
+# define MSZIP_DISTANCE_TABLESIZE ((1 << MSZIP_DISTANCE_TABLEBITS) + \
+ (MSZIP_DISTANCE_MAXSYMBOLS * 2))
+#endif
+
+struct mszipd_stream {
+ struct mspack_system *sys; /* I/O routines */
+ struct mspack_file *input; /* input file handle */
+ struct mspack_file *output; /* output file handle */
+ unsigned int window_posn; /* offset within window */
+
+ /* inflate() will call this whenever the window should be emptied. */
+ int (*flush_window)(struct mszipd_stream *, unsigned int);
+
+ int error, repair_mode, bytes_output;
+
+ /* I/O buffering */
+ unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end, input_end;
+ unsigned int bit_buffer, bits_left, inbuf_size;
+
+
+ /* huffman code lengths */
+ unsigned char LITERAL_len[MSZIP_LITERAL_MAXSYMBOLS];
+ unsigned char DISTANCE_len[MSZIP_DISTANCE_MAXSYMBOLS];
+
+ /* huffman decoding tables */
+ unsigned short LITERAL_table [MSZIP_LITERAL_TABLESIZE];
+ unsigned short DISTANCE_table[MSZIP_DISTANCE_TABLESIZE];
+
+ /* 32kb history window */
+ unsigned char window[MSZIP_FRAME_SIZE];
+};
+
+/* allocates MS-ZIP decompression stream for decoding the given stream.
+ *
+ * - uses system->alloc() to allocate memory
+ *
+ * - returns NULL if not enough memory
+ *
+ * - input_buffer_size is how many bytes to use as an input bitstream buffer
+ *
+ * - if repair_mode is non-zero, errors in decompression will be skipped
+ * and 'holes' left will be filled with zero bytes. This allows at least
+ * a partial recovery of erroneous data.
+ */
+extern struct mszipd_stream *mszipd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int input_buffer_size,
+ int repair_mode);
+
+/* decompresses, or decompresses more of, an MS-ZIP stream.
+ *
+ * - out_bytes of data will be decompressed and the function will return
+ * with an MSPACK_ERR_OK return code.
+ *
+ * - decompressing will stop as soon as out_bytes is reached. if the true
+ * amount of bytes decoded spills over that amount, they will be kept for
+ * a later invocation of mszipd_decompress().
+ *
+ * - the output bytes will be passed to the system->write() function given in
+ * mszipd_init(), using the output file handle given in mszipd_init(). More
+ * than one call may be made to system->write()
+ *
+ * - MS-ZIP will read input bytes as necessary using the system->read()
+ * function given in mszipd_init(), using the input file handle given in
+ * mszipd_init(). This will continue until system->read() returns 0 bytes,
+ * or an error.
+ */
+extern int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes);
+
+/* frees all stream associated with an MS-ZIP data stream
+ *
+ * - calls system->free() using the system pointer given in mszipd_init()
+ */
+void mszipd_free(struct mszipd_stream *zip);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/mszipc.c b/rbutil/rbutilqt/mspack/mszipc.c
new file mode 100644
index 0000000000..2f1ecb2e87
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/mszipc.c
@@ -0,0 +1,18 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The deflate method was created by Phil Katz. MSZIP is equivalent to the
+ * deflate method.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* MS-ZIP compression implementation */
+
+#include <system.h>
+#include <mszip.h>
+
+/* todo */
diff --git a/rbutil/rbutilqt/mspack/mszipd.c b/rbutil/rbutilqt/mspack/mszipd.c
new file mode 100644
index 0000000000..5b7ef4ff4d
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/mszipd.c
@@ -0,0 +1,475 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * The deflate method was created by Phil Katz. MSZIP is equivalent to the
+ * deflate method.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* MS-ZIP decompression implementation. */
+
+#include <system.h>
+#include <mszip.h>
+
+/* import bit-reading macros and code */
+#define BITS_TYPE struct mszipd_stream
+#define BITS_VAR zip
+#define BITS_ORDER_LSB
+#define BITS_LSB_TABLE
+#define READ_BYTES do { \
+ READ_IF_NEEDED; \
+ INJECT_BITS(*i_ptr++, 8); \
+} while (0)
+#include <readbits.h>
+
+/* import huffman macros and code */
+#define TABLEBITS(tbl) MSZIP_##tbl##_TABLEBITS
+#define MAXSYMBOLS(tbl) MSZIP_##tbl##_MAXSYMBOLS
+#define HUFF_TABLE(tbl,idx) zip->tbl##_table[idx]
+#define HUFF_LEN(tbl,idx) zip->tbl##_len[idx]
+#define HUFF_ERROR return INF_ERR_HUFFSYM
+#include <readhuff.h>
+
+#define FLUSH_IF_NEEDED do { \
+ if (zip->window_posn == MSZIP_FRAME_SIZE) { \
+ if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) { \
+ return INF_ERR_FLUSH; \
+ } \
+ zip->window_posn = 0; \
+ } \
+} while (0)
+
+/* match lengths for literal codes 257.. 285 */
+static const unsigned short lit_lengths[29] = {
+ 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27,
+ 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258
+};
+
+/* match offsets for distance codes 0 .. 29 */
+static const unsigned short dist_offsets[30] = {
+ 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385,
+ 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
+};
+
+/* extra bits required for literal codes 257.. 285 */
+static const unsigned char lit_extrabits[29] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2,
+ 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+};
+
+/* extra bits required for distance codes 0 .. 29 */
+static const unsigned char dist_extrabits[30] = {
+ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6,
+ 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+};
+
+/* the order of the bit length Huffman code lengths */
+static const unsigned char bitlen_order[19] = {
+ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+};
+
+/* inflate() error codes */
+#define INF_ERR_BLOCKTYPE (-1) /* unknown block type */
+#define INF_ERR_COMPLEMENT (-2) /* block size complement mismatch */
+#define INF_ERR_FLUSH (-3) /* error from flush_window() callback */
+#define INF_ERR_BITBUF (-4) /* too many bits in bit buffer */
+#define INF_ERR_SYMLENS (-5) /* too many symbols in blocktype 2 header */
+#define INF_ERR_BITLENTBL (-6) /* failed to build bitlens huffman table */
+#define INF_ERR_LITERALTBL (-7) /* failed to build literals huffman table */
+#define INF_ERR_DISTANCETBL (-8) /* failed to build distance huffman table */
+#define INF_ERR_BITOVERRUN (-9) /* bitlen RLE code goes over table size */
+#define INF_ERR_BADBITLEN (-10) /* invalid bit-length code */
+#define INF_ERR_LITCODE (-11) /* out-of-range literal code */
+#define INF_ERR_DISTCODE (-12) /* out-of-range distance code */
+#define INF_ERR_DISTANCE (-13) /* somehow, distance is beyond 32k */
+#define INF_ERR_HUFFSYM (-14) /* out of bits decoding huffman symbol */
+
+static int zip_read_lens(struct mszipd_stream *zip) {
+ /* for the bit buffer and huffman decoding */
+ register unsigned int bit_buffer;
+ register int bits_left;
+ unsigned char *i_ptr, *i_end;
+
+ /* bitlen Huffman codes -- immediate lookup, 7 bit max code length */
+ unsigned short bl_table[(1 << 7)];
+ unsigned char bl_len[19];
+
+ unsigned char lens[MSZIP_LITERAL_MAXSYMBOLS + MSZIP_DISTANCE_MAXSYMBOLS];
+ unsigned int lit_codes, dist_codes, code, last_code=0, bitlen_codes, i, run;
+
+ RESTORE_BITS;
+
+ /* read the number of codes */
+ READ_BITS(lit_codes, 5); lit_codes += 257;
+ READ_BITS(dist_codes, 5); dist_codes += 1;
+ READ_BITS(bitlen_codes, 4); bitlen_codes += 4;
+ if (lit_codes > MSZIP_LITERAL_MAXSYMBOLS) return INF_ERR_SYMLENS;
+ if (dist_codes > MSZIP_DISTANCE_MAXSYMBOLS) return INF_ERR_SYMLENS;
+
+ /* read in the bit lengths in their unusual order */
+ for (i = 0; i < bitlen_codes; i++) READ_BITS(bl_len[bitlen_order[i]], 3);
+ while (i < 19) bl_len[bitlen_order[i++]] = 0;
+
+ /* create decoding table with an immediate lookup */
+ if (make_decode_table(19, 7, &bl_len[0], &bl_table[0])) {
+ return INF_ERR_BITLENTBL;
+ }
+
+ /* read literal / distance code lengths */
+ for (i = 0; i < (lit_codes + dist_codes); i++) {
+ /* single-level huffman lookup */
+ ENSURE_BITS(7);
+ code = bl_table[PEEK_BITS(7)];
+ REMOVE_BITS(bl_len[code]);
+
+ if (code < 16) lens[i] = last_code = code;
+ else {
+ switch (code) {
+ case 16: READ_BITS(run, 2); run += 3; code = last_code; break;
+ case 17: READ_BITS(run, 3); run += 3; code = 0; break;
+ case 18: READ_BITS(run, 7); run += 11; code = 0; break;
+ default: D(("bad code!: %u", code)) return INF_ERR_BADBITLEN;
+ }
+ if ((i + run) > (lit_codes + dist_codes)) return INF_ERR_BITOVERRUN;
+ while (run--) lens[i++] = code;
+ i--;
+ }
+ }
+
+ /* copy LITERAL code lengths and clear any remaining */
+ i = lit_codes;
+ zip->sys->copy(&lens[0], &zip->LITERAL_len[0], i);
+ while (i < MSZIP_LITERAL_MAXSYMBOLS) zip->LITERAL_len[i++] = 0;
+
+ i = dist_codes;
+ zip->sys->copy(&lens[lit_codes], &zip->DISTANCE_len[0], i);
+ while (i < MSZIP_DISTANCE_MAXSYMBOLS) zip->DISTANCE_len[i++] = 0;
+
+ STORE_BITS;
+ return 0;
+}
+
+/* a clean implementation of RFC 1951 / inflate */
+static int inflate(struct mszipd_stream *zip) {
+ unsigned int last_block, block_type, distance, length, this_run, i;
+
+ /* for the bit buffer and huffman decoding */
+ register unsigned int bit_buffer;
+ register int bits_left;
+ register unsigned short sym;
+ unsigned char *i_ptr, *i_end;
+
+ RESTORE_BITS;
+
+ do {
+ /* read in last block bit */
+ READ_BITS(last_block, 1);
+
+ /* read in block type */
+ READ_BITS(block_type, 2);
+
+ if (block_type == 0) {
+ /* uncompressed block */
+ unsigned char lens_buf[4];
+
+ /* go to byte boundary */
+ i = bits_left & 7; REMOVE_BITS(i);
+
+ /* read 4 bytes of data, emptying the bit-buffer if necessary */
+ for (i = 0; (bits_left >= 8); i++) {
+ if (i == 4) return INF_ERR_BITBUF;
+ lens_buf[i] = PEEK_BITS(8);
+ REMOVE_BITS(8);
+ }
+ if (bits_left != 0) return INF_ERR_BITBUF;
+ while (i < 4) {
+ READ_IF_NEEDED;
+ lens_buf[i++] = *i_ptr++;
+ }
+
+ /* get the length and its complement */
+ length = lens_buf[0] | (lens_buf[1] << 8);
+ i = lens_buf[2] | (lens_buf[3] << 8);
+ if (length != (~i & 0xFFFF)) return INF_ERR_COMPLEMENT;
+
+ /* read and copy the uncompressed data into the window */
+ while (length > 0) {
+ READ_IF_NEEDED;
+
+ this_run = length;
+ if (this_run > (unsigned int)(i_end - i_ptr)) this_run = i_end - i_ptr;
+ if (this_run > (MSZIP_FRAME_SIZE - zip->window_posn))
+ this_run = MSZIP_FRAME_SIZE - zip->window_posn;
+
+ zip->sys->copy(i_ptr, &zip->window[zip->window_posn], this_run);
+ zip->window_posn += this_run;
+ i_ptr += this_run;
+ length -= this_run;
+ FLUSH_IF_NEEDED;
+ }
+ }
+ else if ((block_type == 1) || (block_type == 2)) {
+ /* Huffman-compressed LZ77 block */
+ unsigned int match_posn, code;
+
+ if (block_type == 1) {
+ /* block with fixed Huffman codes */
+ i = 0;
+ while (i < 144) zip->LITERAL_len[i++] = 8;
+ while (i < 256) zip->LITERAL_len[i++] = 9;
+ while (i < 280) zip->LITERAL_len[i++] = 7;
+ while (i < 288) zip->LITERAL_len[i++] = 8;
+ for (i = 0; i < 32; i++) zip->DISTANCE_len[i] = 5;
+ }
+ else {
+ /* block with dynamic Huffman codes */
+ STORE_BITS;
+ if ((i = zip_read_lens(zip))) return i;
+ RESTORE_BITS;
+ }
+
+ /* now huffman lengths are read for either kind of block,
+ * create huffman decoding tables */
+ if (make_decode_table(MSZIP_LITERAL_MAXSYMBOLS, MSZIP_LITERAL_TABLEBITS,
+ &zip->LITERAL_len[0], &zip->LITERAL_table[0]))
+ {
+ return INF_ERR_LITERALTBL;
+ }
+
+ if (make_decode_table(MSZIP_DISTANCE_MAXSYMBOLS,MSZIP_DISTANCE_TABLEBITS,
+ &zip->DISTANCE_len[0], &zip->DISTANCE_table[0]))
+ {
+ return INF_ERR_DISTANCETBL;
+ }
+
+ /* decode forever until end of block code */
+ for (;;) {
+ READ_HUFFSYM(LITERAL, code);
+ if (code < 256) {
+ zip->window[zip->window_posn++] = (unsigned char) code;
+ FLUSH_IF_NEEDED;
+ }
+ else if (code == 256) {
+ /* END OF BLOCK CODE: loop break point */
+ break;
+ }
+ else {
+ code -= 257; /* codes 257-285 are matches */
+ if (code >= 29) return INF_ERR_LITCODE; /* codes 286-287 are illegal */
+ READ_BITS_T(length, lit_extrabits[code]);
+ length += lit_lengths[code];
+
+ READ_HUFFSYM(DISTANCE, code);
+ if (code > 30) return INF_ERR_DISTCODE;
+ READ_BITS_T(distance, dist_extrabits[code]);
+ distance += dist_offsets[code];
+
+ /* match position is window position minus distance. If distance
+ * is more than window position numerically, it must 'wrap
+ * around' the frame size. */
+ match_posn = ((distance > zip->window_posn) ? MSZIP_FRAME_SIZE : 0)
+ + zip->window_posn - distance;
+
+ /* copy match */
+ if (length < 12) {
+ /* short match, use slower loop but no loop setup code */
+ while (length--) {
+ zip->window[zip->window_posn++] = zip->window[match_posn++];
+ match_posn &= MSZIP_FRAME_SIZE - 1;
+ FLUSH_IF_NEEDED;
+ }
+ }
+ else {
+ /* longer match, use faster loop but with setup expense */
+ unsigned char *runsrc, *rundest;
+ do {
+ this_run = length;
+ if ((match_posn + this_run) > MSZIP_FRAME_SIZE)
+ this_run = MSZIP_FRAME_SIZE - match_posn;
+ if ((zip->window_posn + this_run) > MSZIP_FRAME_SIZE)
+ this_run = MSZIP_FRAME_SIZE - zip->window_posn;
+
+ rundest = &zip->window[zip->window_posn]; zip->window_posn += this_run;
+ runsrc = &zip->window[match_posn]; match_posn += this_run;
+ length -= this_run;
+ while (this_run--) *rundest++ = *runsrc++;
+ if (match_posn == MSZIP_FRAME_SIZE) match_posn = 0;
+ FLUSH_IF_NEEDED;
+ } while (length > 0);
+ }
+
+ } /* else (code >= 257) */
+
+ } /* for(;;) -- break point at 'code == 256' */
+ }
+ else {
+ /* block_type == 3 -- bad block type */
+ return INF_ERR_BLOCKTYPE;
+ }
+ } while (!last_block);
+
+ /* flush the remaining data */
+ if (zip->window_posn) {
+ if (zip->flush_window(zip, zip->window_posn)) return INF_ERR_FLUSH;
+ }
+ STORE_BITS;
+
+ /* return success */
+ return 0;
+}
+
+/* inflate() calls this whenever the window should be flushed. As
+ * MSZIP only expands to the size of the window, the implementation used
+ * simply keeps track of the amount of data flushed, and if more than 32k
+ * is flushed, an error is raised.
+ */
+static int mszipd_flush_window(struct mszipd_stream *zip,
+ unsigned int data_flushed)
+{
+ zip->bytes_output += data_flushed;
+ if (zip->bytes_output > MSZIP_FRAME_SIZE) {
+ D(("overflow: %u bytes flushed, total is now %u",
+ data_flushed, zip->bytes_output))
+ return 1;
+ }
+ return 0;
+}
+
+struct mszipd_stream *mszipd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int input_buffer_size,
+ int repair_mode)
+{
+ struct mszipd_stream *zip;
+
+ if (!system) return NULL;
+
+ input_buffer_size = (input_buffer_size + 1) & -2;
+ if (!input_buffer_size) return NULL;
+
+ /* allocate decompression state */
+ if (!(zip = (struct mszipd_stream *) system->alloc(system, sizeof(struct mszipd_stream)))) {
+ return NULL;
+ }
+
+ /* allocate input buffer */
+ zip->inbuf = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
+ if (!zip->inbuf) {
+ system->free(zip);
+ return NULL;
+ }
+
+ /* initialise decompression state */
+ zip->sys = system;
+ zip->input = input;
+ zip->output = output;
+ zip->inbuf_size = input_buffer_size;
+ zip->input_end = 0;
+ zip->error = MSPACK_ERR_OK;
+ zip->repair_mode = repair_mode;
+ zip->flush_window = &mszipd_flush_window;
+
+ zip->i_ptr = zip->i_end = &zip->inbuf[0];
+ zip->o_ptr = zip->o_end = NULL;
+ zip->bit_buffer = 0; zip->bits_left = 0;
+ return zip;
+}
+
+int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes) {
+ /* for the bit buffer */
+ register unsigned int bit_buffer;
+ register int bits_left;
+ unsigned char *i_ptr, *i_end;
+
+ int i, state, error;
+
+ /* easy answers */
+ if (!zip || (out_bytes < 0)) return MSPACK_ERR_ARGS;
+ if (zip->error) return zip->error;
+
+ /* flush out any stored-up bytes before we begin */
+ i = zip->o_end - zip->o_ptr;
+ if ((off_t) i > out_bytes) i = (int) out_bytes;
+ if (i) {
+ if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
+ return zip->error = MSPACK_ERR_WRITE;
+ }
+ zip->o_ptr += i;
+ out_bytes -= i;
+ }
+ if (out_bytes == 0) return MSPACK_ERR_OK;
+
+
+ while (out_bytes > 0) {
+ /* unpack another block */
+ RESTORE_BITS;
+
+ /* skip to next read 'CK' header */
+ i = bits_left & 7; REMOVE_BITS(i); /* align to bytestream */
+ state = 0;
+ do {
+ READ_BITS(i, 8);
+ if (i == 'C') state = 1;
+ else if ((state == 1) && (i == 'K')) state = 2;
+ else state = 0;
+ } while (state != 2);
+
+ /* inflate a block, repair and realign if necessary */
+ zip->window_posn = 0;
+ zip->bytes_output = 0;
+ STORE_BITS;
+ if ((error = inflate(zip))) {
+ D(("inflate error %d", error))
+ if (zip->repair_mode) {
+ /* recover partially-inflated buffers */
+ if (zip->bytes_output == 0 && zip->window_posn > 0) {
+ zip->flush_window(zip, zip->window_posn);
+ }
+ zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.",
+ MSZIP_FRAME_SIZE - zip->bytes_output);
+ for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) {
+ zip->window[i] = '\0';
+ }
+ zip->bytes_output = MSZIP_FRAME_SIZE;
+ }
+ else {
+ return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH;
+ }
+ }
+ zip->o_ptr = &zip->window[0];
+ zip->o_end = &zip->o_ptr[zip->bytes_output];
+
+ /* write a frame */
+ i = (out_bytes < (off_t)zip->bytes_output) ?
+ (int)out_bytes : zip->bytes_output;
+ if (zip->sys->write(zip->output, zip->o_ptr, i) != i) {
+ return zip->error = MSPACK_ERR_WRITE;
+ }
+
+ /* mspack errors (i.e. read errors) are fatal and can't be recovered */
+ if ((error > 0) && zip->repair_mode) return error;
+
+ zip->o_ptr += i;
+ out_bytes -= i;
+ }
+
+ if (out_bytes) {
+ D(("bytes left to output"))
+ return zip->error = MSPACK_ERR_DECRUNCH;
+ }
+ return MSPACK_ERR_OK;
+}
+
+void mszipd_free(struct mszipd_stream *zip) {
+ struct mspack_system *sys;
+ if (zip) {
+ sys = zip->sys;
+ sys->free(zip->inbuf);
+ sys->free(zip);
+ }
+}
diff --git a/rbutil/rbutilqt/mspack/qtm.h b/rbutil/rbutilqt/mspack/qtm.h
new file mode 100644
index 0000000000..ab0bb4c32c
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/qtm.h
@@ -0,0 +1,128 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The Quantum method was created by David Stafford, adapted by Microsoft
+ * Corporation.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_QTM_H
+#define MSPACK_QTM_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Quantum compression / decompression definitions */
+
+#define QTM_FRAME_SIZE (32768)
+
+struct qtmd_modelsym {
+ unsigned short sym, cumfreq;
+};
+
+struct qtmd_model {
+ int shiftsleft, entries;
+ struct qtmd_modelsym *syms;
+};
+
+struct qtmd_stream {
+ struct mspack_system *sys; /* I/O routines */
+ struct mspack_file *input; /* input file handle */
+ struct mspack_file *output; /* output file handle */
+
+ unsigned char *window; /* decoding window */
+ unsigned int window_size; /* window size */
+ unsigned int window_posn; /* decompression offset within window */
+ unsigned int frame_todo; /* bytes remaining for current frame */
+
+ unsigned short H, L, C; /* high/low/current: arith coding state */
+ unsigned char header_read; /* have we started decoding a new frame? */
+
+ int error;
+
+ /* I/O buffers */
+ unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end;
+ unsigned int bit_buffer, inbuf_size;
+ unsigned char bits_left, input_end;
+
+ /* four literal models, each representing 64 symbols
+ * model0 for literals from 0 to 63 (selector = 0)
+ * model1 for literals from 64 to 127 (selector = 1)
+ * model2 for literals from 128 to 191 (selector = 2)
+ * model3 for literals from 129 to 255 (selector = 3) */
+ struct qtmd_model model0, model1, model2, model3;
+
+ /* three match models.
+ * model4 for match with fixed length of 3 bytes
+ * model5 for match with fixed length of 4 bytes
+ * model6 for variable length match, encoded with model6len model */
+ struct qtmd_model model4, model5, model6, model6len;
+
+ /* selector model. 0-6 to say literal (0,1,2,3) or match (4,5,6) */
+ struct qtmd_model model7;
+
+ /* symbol arrays for all models */
+ struct qtmd_modelsym m0sym[64 + 1];
+ struct qtmd_modelsym m1sym[64 + 1];
+ struct qtmd_modelsym m2sym[64 + 1];
+ struct qtmd_modelsym m3sym[64 + 1];
+ struct qtmd_modelsym m4sym[24 + 1];
+ struct qtmd_modelsym m5sym[36 + 1];
+ struct qtmd_modelsym m6sym[42 + 1], m6lsym[27 + 1];
+ struct qtmd_modelsym m7sym[7 + 1];
+};
+
+/* allocates Quantum decompression state for decoding the given stream.
+ *
+ * - returns NULL if window_bits is outwith the range 10 to 21 (inclusive).
+ *
+ * - uses system->alloc() to allocate memory
+ *
+ * - returns NULL if not enough memory
+ *
+ * - window_bits is the size of the Quantum window, from 1Kb (10) to 2Mb (21).
+ *
+ * - input_buffer_size is the number of bytes to use to store bitstream data.
+ */
+extern struct qtmd_stream *qtmd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int window_bits,
+ int input_buffer_size);
+
+/* decompresses, or decompresses more of, a Quantum stream.
+ *
+ * - out_bytes of data will be decompressed and the function will return
+ * with an MSPACK_ERR_OK return code.
+ *
+ * - decompressing will stop as soon as out_bytes is reached. if the true
+ * amount of bytes decoded spills over that amount, they will be kept for
+ * a later invocation of qtmd_decompress().
+ *
+ * - the output bytes will be passed to the system->write() function given in
+ * qtmd_init(), using the output file handle given in qtmd_init(). More
+ * than one call may be made to system->write()
+ *
+ * - Quantum will read input bytes as necessary using the system->read()
+ * function given in qtmd_init(), using the input file handle given in
+ * qtmd_init(). This will continue until system->read() returns 0 bytes,
+ * or an error.
+ */
+extern int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes);
+
+/* frees all state associated with a Quantum data stream
+ *
+ * - calls system->free() using the system pointer given in qtmd_init()
+ */
+void qtmd_free(struct qtmd_stream *qtm);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/qtmd.c b/rbutil/rbutilqt/mspack/qtmd.c
new file mode 100644
index 0000000000..12b27f5608
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/qtmd.c
@@ -0,0 +1,489 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * The Quantum method was created by David Stafford, adapted by Microsoft
+ * Corporation.
+ *
+ * This decompressor is based on an implementation by Matthew Russotto, used
+ * with permission.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* Quantum decompression implementation */
+
+/* This decompressor was researched and implemented by Matthew Russotto. It
+ * has since been tidied up by Stuart Caie. More information can be found at
+ * http://www.speakeasy.org/~russotto/quantumcomp.html
+ */
+
+#include <system.h>
+#include <qtm.h>
+
+/* import bit-reading macros and code */
+#define BITS_TYPE struct qtmd_stream
+#define BITS_VAR qtm
+#define BITS_ORDER_MSB
+#define READ_BYTES do { \
+ unsigned char b0, b1; \
+ READ_IF_NEEDED; b0 = *i_ptr++; \
+ READ_IF_NEEDED; b1 = *i_ptr++; \
+ INJECT_BITS((b0 << 8) | b1, 16); \
+} while (0)
+#include <readbits.h>
+
+/* Quantum static data tables:
+ *
+ * Quantum uses 'position slots' to represent match offsets. For every
+ * match, a small 'position slot' number and a small offset from that slot
+ * are encoded instead of one large offset.
+ *
+ * position_base[] is an index to the position slot bases
+ *
+ * extra_bits[] states how many bits of offset-from-base data is needed.
+ *
+ * length_base[] and length_extra[] are equivalent in function, but are
+ * used for encoding selector 6 (variable length match) match lengths,
+ * instead of match offsets.
+ *
+ * They are generated with the following code:
+ * unsigned int i, offset;
+ * for (i = 0, offset = 0; i < 42; i++) {
+ * position_base[i] = offset;
+ * extra_bits[i] = ((i < 2) ? 0 : (i - 2)) >> 1;
+ * offset += 1 << extra_bits[i];
+ * }
+ * for (i = 0, offset = 0; i < 26; i++) {
+ * length_base[i] = offset;
+ * length_extra[i] = (i < 2 ? 0 : i - 2) >> 2;
+ * offset += 1 << length_extra[i];
+ * }
+ * length_base[26] = 254; length_extra[26] = 0;
+ */
+static const unsigned int position_base[42] = {
+ 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
+ 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152,
+ 65536, 98304, 131072, 196608, 262144, 393216, 524288, 786432, 1048576, 1572864
+};
+static const unsigned char extra_bits[42] = {
+ 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
+ 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19
+};
+static const unsigned char length_base[27] = {
+ 0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 18, 22, 26,
+ 30, 38, 46, 54, 62, 78, 94, 110, 126, 158, 190, 222, 254
+};
+static const unsigned char length_extra[27] = {
+ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+ 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+};
+
+
+/* Arithmetic decoder:
+ *
+ * GET_SYMBOL(model, var) fetches the next symbol from the stated model
+ * and puts it in var.
+ *
+ * If necessary, qtmd_update_model() is called.
+ */
+#define GET_SYMBOL(model, var) do { \
+ range = ((H - L) & 0xFFFF) + 1; \
+ symf = ((((C - L + 1) * model.syms[0].cumfreq)-1) / range) & 0xFFFF; \
+ \
+ for (i = 1; i < model.entries; i++) { \
+ if (model.syms[i].cumfreq <= symf) break; \
+ } \
+ (var) = model.syms[i-1].sym; \
+ \
+ range = (H - L) + 1; \
+ symf = model.syms[0].cumfreq; \
+ H = L + ((model.syms[i-1].cumfreq * range) / symf) - 1; \
+ L = L + ((model.syms[i].cumfreq * range) / symf); \
+ \
+ do { model.syms[--i].cumfreq += 8; } while (i > 0); \
+ if (model.syms[0].cumfreq > 3800) qtmd_update_model(&model); \
+ \
+ while (1) { \
+ if ((L & 0x8000) != (H & 0x8000)) { \
+ if ((L & 0x4000) && !(H & 0x4000)) { \
+ /* underflow case */ \
+ C ^= 0x4000; L &= 0x3FFF; H |= 0x4000; \
+ } \
+ else break; \
+ } \
+ L <<= 1; H = (H << 1) | 1; \
+ ENSURE_BITS(1); \
+ C = (C << 1) | PEEK_BITS(1); \
+ REMOVE_BITS(1); \
+ } \
+} while (0)
+
+static void qtmd_update_model(struct qtmd_model *model) {
+ struct qtmd_modelsym tmp;
+ int i, j;
+
+ if (--model->shiftsleft) {
+ for (i = model->entries - 1; i >= 0; i--) {
+ /* -1, not -2; the 0 entry saves this */
+ model->syms[i].cumfreq >>= 1;
+ if (model->syms[i].cumfreq <= model->syms[i+1].cumfreq) {
+ model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1;
+ }
+ }
+ }
+ else {
+ model->shiftsleft = 50;
+ for (i = 0; i < model->entries; i++) {
+ /* no -1, want to include the 0 entry */
+ /* this converts cumfreqs into frequencies, then shifts right */
+ model->syms[i].cumfreq -= model->syms[i+1].cumfreq;
+ model->syms[i].cumfreq++; /* avoid losing things entirely */
+ model->syms[i].cumfreq >>= 1;
+ }
+
+ /* now sort by frequencies, decreasing order -- this must be an
+ * inplace selection sort, or a sort with the same (in)stability
+ * characteristics */
+ for (i = 0; i < model->entries - 1; i++) {
+ for (j = i + 1; j < model->entries; j++) {
+ if (model->syms[i].cumfreq < model->syms[j].cumfreq) {
+ tmp = model->syms[i];
+ model->syms[i] = model->syms[j];
+ model->syms[j] = tmp;
+ }
+ }
+ }
+
+ /* then convert frequencies back to cumfreq */
+ for (i = model->entries - 1; i >= 0; i--) {
+ model->syms[i].cumfreq += model->syms[i+1].cumfreq;
+ }
+ }
+}
+
+/* Initialises a model to decode symbols from [start] to [start]+[len]-1 */
+static void qtmd_init_model(struct qtmd_model *model,
+ struct qtmd_modelsym *syms, int start, int len)
+{
+ int i;
+
+ model->shiftsleft = 4;
+ model->entries = len;
+ model->syms = syms;
+
+ for (i = 0; i <= len; i++) {
+ syms[i].sym = start + i; /* actual symbol */
+ syms[i].cumfreq = len - i; /* current frequency of that symbol */
+ }
+}
+
+
+/*-------- main Quantum code --------*/
+
+struct qtmd_stream *qtmd_init(struct mspack_system *system,
+ struct mspack_file *input,
+ struct mspack_file *output,
+ int window_bits, int input_buffer_size)
+{
+ unsigned int window_size = 1 << window_bits;
+ struct qtmd_stream *qtm;
+ int i;
+
+ if (!system) return NULL;
+
+ /* Quantum supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */
+ if (window_bits < 10 || window_bits > 21) return NULL;
+
+ input_buffer_size = (input_buffer_size + 1) & -2;
+ if (input_buffer_size < 2) return NULL;
+
+ /* allocate decompression state */
+ if (!(qtm = (struct qtmd_stream *) system->alloc(system, sizeof(struct qtmd_stream)))) {
+ return NULL;
+ }
+
+ /* allocate decompression window and input buffer */
+ qtm->window = (unsigned char *) system->alloc(system, (size_t) window_size);
+ qtm->inbuf = (unsigned char *) system->alloc(system, (size_t) input_buffer_size);
+ if (!qtm->window || !qtm->inbuf) {
+ system->free(qtm->window);
+ system->free(qtm->inbuf);
+ system->free(qtm);
+ return NULL;
+ }
+
+ /* initialise decompression state */
+ qtm->sys = system;
+ qtm->input = input;
+ qtm->output = output;
+ qtm->inbuf_size = input_buffer_size;
+ qtm->window_size = window_size;
+ qtm->window_posn = 0;
+ qtm->frame_todo = QTM_FRAME_SIZE;
+ qtm->header_read = 0;
+ qtm->error = MSPACK_ERR_OK;
+
+ qtm->i_ptr = qtm->i_end = &qtm->inbuf[0];
+ qtm->o_ptr = qtm->o_end = &qtm->window[0];
+ qtm->input_end = 0;
+ qtm->bits_left = 0;
+ qtm->bit_buffer = 0;
+
+ /* initialise arithmetic coding models
+ * - model 4 depends on window size, ranges from 20 to 24
+ * - model 5 depends on window size, ranges from 20 to 36
+ * - model 6pos depends on window size, ranges from 20 to 42
+ */
+ i = window_bits * 2;
+ qtmd_init_model(&qtm->model0, &qtm->m0sym[0], 0, 64);
+ qtmd_init_model(&qtm->model1, &qtm->m1sym[0], 64, 64);
+ qtmd_init_model(&qtm->model2, &qtm->m2sym[0], 128, 64);
+ qtmd_init_model(&qtm->model3, &qtm->m3sym[0], 192, 64);
+ qtmd_init_model(&qtm->model4, &qtm->m4sym[0], 0, (i > 24) ? 24 : i);
+ qtmd_init_model(&qtm->model5, &qtm->m5sym[0], 0, (i > 36) ? 36 : i);
+ qtmd_init_model(&qtm->model6, &qtm->m6sym[0], 0, i);
+ qtmd_init_model(&qtm->model6len, &qtm->m6lsym[0], 0, 27);
+ qtmd_init_model(&qtm->model7, &qtm->m7sym[0], 0, 7);
+
+ /* all ok */
+ return qtm;
+}
+
+int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes) {
+ unsigned int frame_todo, frame_end, window_posn, match_offset, range;
+ unsigned char *window, *i_ptr, *i_end, *runsrc, *rundest;
+ int i, j, selector, extra, sym, match_length;
+ unsigned short H, L, C, symf;
+
+ register unsigned int bit_buffer;
+ register unsigned char bits_left;
+
+ /* easy answers */
+ if (!qtm || (out_bytes < 0)) return MSPACK_ERR_ARGS;
+ if (qtm->error) return qtm->error;
+
+ /* flush out any stored-up bytes before we begin */
+ i = qtm->o_end - qtm->o_ptr;
+ if ((off_t) i > out_bytes) i = (int) out_bytes;
+ if (i) {
+ if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
+ return qtm->error = MSPACK_ERR_WRITE;
+ }
+ qtm->o_ptr += i;
+ out_bytes -= i;
+ }
+ if (out_bytes == 0) return MSPACK_ERR_OK;
+
+ /* restore local state */
+ RESTORE_BITS;
+ window = qtm->window;
+ window_posn = qtm->window_posn;
+ frame_todo = qtm->frame_todo;
+ H = qtm->H;
+ L = qtm->L;
+ C = qtm->C;
+
+ /* while we do not have enough decoded bytes in reserve: */
+ while ((qtm->o_end - qtm->o_ptr) < out_bytes) {
+ /* read header if necessary. Initialises H, L and C */
+ if (!qtm->header_read) {
+ H = 0xFFFF; L = 0; READ_BITS(C, 16);
+ qtm->header_read = 1;
+ }
+
+ /* decode more, up to the number of bytes needed, the frame boundary,
+ * or the window boundary, whichever comes first */
+ frame_end = window_posn + (out_bytes - (qtm->o_end - qtm->o_ptr));
+ if ((window_posn + frame_todo) < frame_end) {
+ frame_end = window_posn + frame_todo;
+ }
+ if (frame_end > qtm->window_size) {
+ frame_end = qtm->window_size;
+ }
+
+ while (window_posn < frame_end) {
+ GET_SYMBOL(qtm->model7, selector);
+ if (selector < 4) {
+ /* literal byte */
+ struct qtmd_model *mdl = (selector == 0) ? &qtm->model0 :
+ ((selector == 1) ? &qtm->model1 :
+ ((selector == 2) ? &qtm->model2 :
+ &qtm->model3));
+ GET_SYMBOL((*mdl), sym);
+ window[window_posn++] = sym;
+ frame_todo--;
+ }
+ else {
+ /* match repeated string */
+ switch (selector) {
+ case 4: /* selector 4 = fixed length match (3 bytes) */
+ GET_SYMBOL(qtm->model4, sym);
+ READ_MANY_BITS(extra, extra_bits[sym]);
+ match_offset = position_base[sym] + extra + 1;
+ match_length = 3;
+ break;
+
+ case 5: /* selector 5 = fixed length match (4 bytes) */
+ GET_SYMBOL(qtm->model5, sym);
+ READ_MANY_BITS(extra, extra_bits[sym]);
+ match_offset = position_base[sym] + extra + 1;
+ match_length = 4;
+ break;
+
+ case 6: /* selector 6 = variable length match */
+ GET_SYMBOL(qtm->model6len, sym);
+ READ_MANY_BITS(extra, length_extra[sym]);
+ match_length = length_base[sym] + extra + 5;
+
+ GET_SYMBOL(qtm->model6, sym);
+ READ_MANY_BITS(extra, extra_bits[sym]);
+ match_offset = position_base[sym] + extra + 1;
+ break;
+
+ default:
+ /* should be impossible, model7 can only return 0-6 */
+ D(("got %d from selector", selector))
+ return qtm->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ rundest = &window[window_posn];
+ frame_todo -= match_length;
+
+ /* does match destination wrap the window? This situation is possible
+ * where the window size is less than the 32k frame size, but matches
+ * must not go beyond a frame boundary */
+ if ((window_posn + match_length) > qtm->window_size) {
+ /* copy first part of match, before window end */
+ i = qtm->window_size - window_posn;
+ j = window_posn - match_offset;
+ while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
+
+ /* flush currently stored data */
+ i = (&window[qtm->window_size] - qtm->o_ptr);
+
+ /* this should not happen, but if it does then this code
+ * can't handle the situation (can't flush up to the end of
+ * the window, but can't break out either because we haven't
+ * finished writing the match). bail out in this case */
+ if (i > out_bytes) {
+ D(("during window-wrap match; %d bytes to flush but only need %d",
+ i, (int) out_bytes))
+ return qtm->error = MSPACK_ERR_DECRUNCH;
+ }
+ if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
+ return qtm->error = MSPACK_ERR_WRITE;
+ }
+ out_bytes -= i;
+ qtm->o_ptr = &window[0];
+ qtm->o_end = &window[0];
+
+ /* copy second part of match, after window wrap */
+ rundest = &window[0];
+ i = match_length - (qtm->window_size - window_posn);
+ while (i--) *rundest++ = window[j++ & (qtm->window_size - 1)];
+ window_posn = window_posn + match_length - qtm->window_size;
+
+ break; /* because "window_posn < frame_end" has now failed */
+ }
+ else {
+ /* normal match - output won't wrap window or frame end */
+ i = match_length;
+
+ /* does match _offset_ wrap the window? */
+ if (match_offset > window_posn) {
+ /* j = length from match offset to end of window */
+ j = match_offset - window_posn;
+ if (j > (int) qtm->window_size) {
+ D(("match offset beyond window boundaries"))
+ return qtm->error = MSPACK_ERR_DECRUNCH;
+ }
+ runsrc = &window[qtm->window_size - j];
+ if (j < i) {
+ /* if match goes over the window edge, do two copy runs */
+ i -= j; while (j-- > 0) *rundest++ = *runsrc++;
+ runsrc = window;
+ }
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+ else {
+ runsrc = rundest - match_offset;
+ while (i-- > 0) *rundest++ = *runsrc++;
+ }
+ window_posn += match_length;
+ }
+ } /* if (window_posn+match_length > frame_end) */
+ } /* while (window_posn < frame_end) */
+
+ qtm->o_end = &window[window_posn];
+
+ /* if we subtracted too much from frame_todo, it will
+ * wrap around past zero and go above its max value */
+ if (frame_todo > QTM_FRAME_SIZE) {
+ D(("overshot frame alignment"))
+ return qtm->error = MSPACK_ERR_DECRUNCH;
+ }
+
+ /* another frame completed? */
+ if (frame_todo == 0) {
+ /* re-align input */
+ if (bits_left & 7) REMOVE_BITS(bits_left & 7);
+
+ /* special Quantum hack -- cabd.c injects a trailer byte to allow the
+ * decompressor to realign itself. CAB Quantum blocks, unlike LZX
+ * blocks, can have anything from 0 to 4 trailing null bytes. */
+ do { READ_BITS(i, 8); } while (i != 0xFF);
+
+ qtm->header_read = 0;
+
+ frame_todo = QTM_FRAME_SIZE;
+ }
+
+ /* window wrap? */
+ if (window_posn == qtm->window_size) {
+ /* flush all currently stored data */
+ i = (qtm->o_end - qtm->o_ptr);
+ /* break out if we have more than enough to finish this request */
+ if (i >= out_bytes) break;
+ if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
+ return qtm->error = MSPACK_ERR_WRITE;
+ }
+ out_bytes -= i;
+ qtm->o_ptr = &window[0];
+ qtm->o_end = &window[0];
+ window_posn = 0;
+ }
+
+ } /* while (more bytes needed) */
+
+ if (out_bytes) {
+ i = (int) out_bytes;
+ if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) {
+ return qtm->error = MSPACK_ERR_WRITE;
+ }
+ qtm->o_ptr += i;
+ }
+
+ /* store local state */
+
+ STORE_BITS;
+ qtm->window_posn = window_posn;
+ qtm->frame_todo = frame_todo;
+ qtm->H = H;
+ qtm->L = L;
+ qtm->C = C;
+
+ return MSPACK_ERR_OK;
+}
+
+void qtmd_free(struct qtmd_stream *qtm) {
+ struct mspack_system *sys;
+ if (qtm) {
+ sys = qtm->sys;
+ sys->free(qtm->window);
+ sys->free(qtm->inbuf);
+ sys->free(qtm);
+ }
+}
diff --git a/rbutil/rbutilqt/mspack/readbits.h b/rbutil/rbutilqt/mspack/readbits.h
new file mode 100644
index 0000000000..457cbdd7d4
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/readbits.h
@@ -0,0 +1,207 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_READBITS_H
+#define MSPACK_READBITS_H 1
+
+/* this header defines macros that read data streams by
+ * the individual bits
+ *
+ * INIT_BITS initialises bitstream state in state structure
+ * STORE_BITS stores bitstream state in state structure
+ * RESTORE_BITS restores bitstream state from state structure
+ * ENSURE_BITS(n) ensure there are at least N bits in the bit buffer
+ * READ_BITS(var,n) takes N bits from the buffer and puts them in var
+ * PEEK_BITS(n) extracts without removing N bits from the bit buffer
+ * REMOVE_BITS(n) removes N bits from the bit buffer
+ *
+ * READ_BITS simply calls ENSURE_BITS, PEEK_BITS and REMOVE_BITS,
+ * which means it's limited to reading the number of bits you can
+ * ensure at any one time. It also fails if asked to read zero bits.
+ * If you need to read zero bits, or more bits than can be ensured in
+ * one go, use READ_MANY_BITS instead.
+ *
+ * These macros have variable names baked into them, so to use them
+ * you have to define some macros:
+ * - BITS_TYPE: the type name of your state structure
+ * - BITS_VAR: the variable that points to your state structure
+ * - define BITS_ORDER_MSB if bits are read from the MSB, or
+ * define BITS_ORDER_LSB if bits are read from the LSB
+ * - READ_BYTES: some code that reads more data into the bit buffer,
+ * it should use READ_IF_NEEDED (calls read_input if the byte buffer
+ * is empty), then INJECT_BITS(data,n) to put data from the byte
+ * buffer into the bit buffer.
+ *
+ * You also need to define some variables and structure members:
+ * - unsigned char *i_ptr; // current position in the byte buffer
+ * - unsigned char *i_end; // end of the byte buffer
+ * - unsigned int bit_buffer; // the bit buffer itself
+ * - unsigned int bits_left; // number of bits remaining
+ *
+ * If you use read_input() and READ_IF_NEEDED, they also expect these
+ * structure members:
+ * - struct mspack_system *sys; // to access sys->read()
+ * - unsigned int error; // to record/return read errors
+ * - unsigned char input_end; // to mark reaching the EOF
+ * - unsigned char *inbuf; // the input byte buffer
+ * - unsigned int inbuf_size; // the size of the input byte buffer
+ *
+ * Your READ_BYTES implementation should read data from *i_ptr and
+ * put them in the bit buffer. READ_IF_NEEDED will call read_input()
+ * if i_ptr reaches i_end, and will fill up inbuf and set i_ptr to
+ * the start of inbuf and i_end to the end of inbuf.
+ *
+ * If you're reading in MSB order, the routines work by using the area
+ * beyond the MSB and the LSB of the bit buffer as a free source of
+ * zeroes when shifting. This avoids having to mask any bits. So we
+ * have to know the bit width of the bit buffer variable. We use
+ * <limits.h> and CHAR_BIT to find the size of the bit buffer in bits.
+ *
+ * If you are reading in LSB order, bits need to be masked. Normally
+ * this is done by computing the mask: N bits are masked by the value
+ * (1<<N)-1). However, you can define BITS_LSB_TABLE to use a lookup
+ * table instead of computing this. This adds two new macros,
+ * PEEK_BITS_T and READ_BITS_T which work the same way as PEEK_BITS
+ * and READ_BITS, except they use this lookup table. This is useful if
+ * you need to look up a number of bits that are only known at
+ * runtime, so the bit mask can't be turned into a constant by the
+ * compiler.
+
+ * The bit buffer datatype should be at least 32 bits wide: it must be
+ * possible to ENSURE_BITS(17), so it must be possible to add 16 new bits
+ * to the bit buffer when the bit buffer already has 1 to 15 bits left.
+ */
+
+#ifndef BITS_VAR
+# error "define BITS_VAR as the state structure poiner variable name"
+#endif
+#ifndef BITS_TYPE
+# error "define BITS_TYPE as the state structure type"
+#endif
+#if defined(BITS_ORDER_MSB) && defined(BITS_ORDER_LSB)
+# error "you must define either BITS_ORDER_MSB or BITS_ORDER_LSB"
+#else
+# if !(defined(BITS_ORDER_MSB) || defined(BITS_ORDER_LSB))
+# error "you must define BITS_ORDER_MSB or BITS_ORDER_LSB"
+# endif
+#endif
+
+#if HAVE_LIMITS_H
+# include <limits.h>
+#endif
+#ifndef CHAR_BIT
+# define CHAR_BIT (8)
+#endif
+#define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT)
+
+#define INIT_BITS do { \
+ BITS_VAR->i_ptr = &BITS_VAR->inbuf[0]; \
+ BITS_VAR->i_end = &BITS_VAR->inbuf[0]; \
+ BITS_VAR->bit_buffer = 0; \
+ BITS_VAR->bits_left = 0; \
+ BITS_VAR->input_end = 0; \
+} while (0)
+
+#define STORE_BITS do { \
+ BITS_VAR->i_ptr = i_ptr; \
+ BITS_VAR->i_end = i_end; \
+ BITS_VAR->bit_buffer = bit_buffer; \
+ BITS_VAR->bits_left = bits_left; \
+} while (0)
+
+#define RESTORE_BITS do { \
+ i_ptr = BITS_VAR->i_ptr; \
+ i_end = BITS_VAR->i_end; \
+ bit_buffer = BITS_VAR->bit_buffer; \
+ bits_left = BITS_VAR->bits_left; \
+} while (0)
+
+#define ENSURE_BITS(nbits) do { \
+ while (bits_left < (nbits)) READ_BYTES; \
+} while (0)
+
+#define READ_BITS(val, nbits) do { \
+ ENSURE_BITS(nbits); \
+ (val) = PEEK_BITS(nbits); \
+ REMOVE_BITS(nbits); \
+} while (0)
+
+#define READ_MANY_BITS(val, bits) do { \
+ unsigned char needed = (bits), bitrun; \
+ (val) = 0; \
+ while (needed > 0) { \
+ if (bits_left <= (BITBUF_WIDTH - 16)) READ_BYTES; \
+ bitrun = (bits_left < needed) ? bits_left : needed; \
+ (val) = ((val) << bitrun) | PEEK_BITS(bitrun); \
+ REMOVE_BITS(bitrun); \
+ needed -= bitrun; \
+ } \
+} while (0)
+
+#ifdef BITS_ORDER_MSB
+# define PEEK_BITS(nbits) (bit_buffer >> (BITBUF_WIDTH - (nbits)))
+# define REMOVE_BITS(nbits) ((bit_buffer <<= (nbits)), (bits_left -= (nbits)))
+# define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
+ (bitdata) << (BITBUF_WIDTH - (nbits) - bits_left)), (bits_left += (nbits)))
+#else /* BITS_ORDER_LSB */
+# define PEEK_BITS(nbits) (bit_buffer & ((1 << (nbits))-1))
+# define REMOVE_BITS(nbits) ((bit_buffer >>= (nbits)), (bits_left -= (nbits)))
+# define INJECT_BITS(bitdata,nbits) ((bit_buffer |= \
+ (bitdata) << bits_left), (bits_left += (nbits)))
+#endif
+
+#ifdef BITS_LSB_TABLE
+/* lsb_bit_mask[n] = (1 << n) - 1 */
+static const unsigned short lsb_bit_mask[17] = {
+ 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
+ 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
+};
+# define PEEK_BITS_T(nbits) (bit_buffer & lsb_bit_mask[(nbits)])
+# define READ_BITS_T(val, nbits) do { \
+ ENSURE_BITS(nbits); \
+ (val) = PEEK_BITS_T(nbits); \
+ REMOVE_BITS(nbits); \
+} while (0)
+#endif
+
+#ifndef BITS_NO_READ_INPUT
+# define READ_IF_NEEDED do { \
+ if (i_ptr >= i_end) { \
+ if (read_input(BITS_VAR)) \
+ return BITS_VAR->error; \
+ i_ptr = BITS_VAR->i_ptr; \
+ i_end = BITS_VAR->i_end; \
+ } \
+} while (0)
+
+static int read_input(BITS_TYPE *p) {
+ int read = p->sys->read(p->input, &p->inbuf[0], (int)p->inbuf_size);
+ if (read < 0) return p->error = MSPACK_ERR_READ;
+
+ /* we might overrun the input stream by asking for bits we don't use,
+ * so fake 2 more bytes at the end of input */
+ if (read == 0) {
+ if (p->input_end) {
+ D(("out of input bytes"))
+ return p->error = MSPACK_ERR_READ;
+ }
+ else {
+ read = 2;
+ p->inbuf[0] = p->inbuf[1] = 0;
+ p->input_end = 1;
+ }
+ }
+
+ /* update i_ptr and i_end */
+ p->i_ptr = &p->inbuf[0];
+ p->i_end = &p->inbuf[read];
+ return MSPACK_ERR_OK;
+}
+#endif
+#endif
diff --git a/rbutil/rbutilqt/mspack/readhuff.h b/rbutil/rbutilqt/mspack/readhuff.h
new file mode 100644
index 0000000000..bb15c0a123
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/readhuff.h
@@ -0,0 +1,173 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_READHUFF_H
+#define MSPACK_READHUFF_H 1
+
+/* This implements a fast Huffman tree decoding system.
+ */
+
+#if !(defined(BITS_ORDER_MSB) || defined(BITS_ORDER_LSB))
+# error "readhuff.h is used in conjunction with readbits.h, include that first"
+#endif
+#if !(defined(TABLEBITS) && defined(MAXSYMBOLS))
+# error "define TABLEBITS(tbl) and MAXSYMBOLS(tbl) before using readhuff.h"
+#endif
+#if !(defined(HUFF_TABLE) && defined(HUFF_LEN))
+# error "define HUFF_TABLE(tbl) and HUFF_LEN(tbl) before using readhuff.h"
+#endif
+#ifndef HUFF_ERROR
+# error "define HUFF_ERROR before using readhuff.h"
+#endif
+#ifndef HUFF_MAXBITS
+# define HUFF_MAXBITS 16
+#endif
+
+/* Decodes the next huffman symbol from the input bitstream into var.
+ * Do not use this macro on a table unless build_decode_table() succeeded.
+ */
+#define READ_HUFFSYM(tbl, var) do { \
+ ENSURE_BITS(HUFF_MAXBITS); \
+ sym = HUFF_TABLE(tbl, PEEK_BITS(TABLEBITS(tbl))); \
+ if (sym >= MAXSYMBOLS(tbl)) HUFF_TRAVERSE(tbl); \
+ (var) = sym; \
+ i = HUFF_LEN(tbl, sym); \
+ REMOVE_BITS(i); \
+} while (0)
+
+#ifdef BITS_ORDER_LSB
+# define HUFF_TRAVERSE(tbl) do { \
+ i = TABLEBITS(tbl) - 1; \
+ do { \
+ if (i++ > HUFF_MAXBITS) HUFF_ERROR; \
+ sym = HUFF_TABLE(tbl, \
+ (sym << 1) | ((bit_buffer >> i) & 1)); \
+ } while (sym >= MAXSYMBOLS(tbl)); \
+} while (0)
+#else
+#define HUFF_TRAVERSE(tbl) do { \
+ i = 1 << (BITBUF_WIDTH - TABLEBITS(tbl)); \
+ do { \
+ if ((i >>= 1) == 0) HUFF_ERROR; \
+ sym = HUFF_TABLE(tbl, \
+ (sym << 1) | ((bit_buffer & i) ? 1 : 0)); \
+ } while (sym >= MAXSYMBOLS(tbl)); \
+} while (0)
+#endif
+
+/* make_decode_table(nsyms, nbits, length[], table[])
+ *
+ * This function was originally coded by David Tritscher.
+ * It builds a fast huffman decoding table from
+ * a canonical huffman code lengths table.
+ *
+ * nsyms = total number of symbols in this huffman tree.
+ * nbits = any symbols with a code length of nbits or less can be decoded
+ * in one lookup of the table.
+ * length = A table to get code lengths from [0 to nsyms-1]
+ * table = The table to fill up with decoded symbols and pointers.
+ * Should be ((1<<nbits) + (nsyms*2)) in length.
+ *
+ * Returns 0 for OK or 1 for error
+ */
+static int make_decode_table(unsigned int nsyms, unsigned int nbits,
+ unsigned char *length, unsigned short *table)
+{
+ register unsigned short sym, next_symbol;
+ register unsigned int leaf, fill;
+#ifdef BITS_ORDER_LSB
+ register unsigned int reverse;
+#endif
+ register unsigned char bit_num;
+ unsigned int pos = 0; /* the current position in the decode table */
+ unsigned int table_mask = 1 << nbits;
+ unsigned int bit_mask = table_mask >> 1; /* don't do 0 length codes */
+
+ /* fill entries for codes short enough for a direct mapping */
+ for (bit_num = 1; bit_num <= nbits; bit_num++) {
+ for (sym = 0; sym < nsyms; sym++) {
+ if (length[sym] != bit_num) continue;
+#ifdef BITS_ORDER_MSB
+ leaf = pos;
+#else
+ /* reverse the significant bits */
+ fill = length[sym]; reverse = pos >> (nbits - fill); leaf = 0;
+ do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+#endif
+
+ if((pos += bit_mask) > table_mask) return 1; /* table overrun */
+
+ /* fill all possible lookups of this symbol with the symbol itself */
+#ifdef BITS_ORDER_MSB
+ for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym;
+#else
+ fill = bit_mask; next_symbol = 1 << bit_num;
+ do { table[leaf] = sym; leaf += next_symbol; } while (--fill);
+#endif
+ }
+ bit_mask >>= 1;
+ }
+
+ /* exit with success if table is now complete */
+ if (pos == table_mask) return 0;
+
+ /* mark all remaining table entries as unused */
+ for (sym = pos; sym < table_mask; sym++) {
+#ifdef BITS_ORDER_MSB
+ table[sym] = 0xFFFF;
+#else
+ reverse = sym; leaf = 0; fill = nbits;
+ do { leaf <<= 1; leaf |= reverse & 1; reverse >>= 1; } while (--fill);
+ table[leaf] = 0xFFFF;
+#endif
+ }
+
+ /* next_symbol = base of allocation for long codes */
+ next_symbol = ((table_mask >> 1) < nsyms) ? nsyms : (table_mask >> 1);
+
+ /* give ourselves room for codes to grow by up to 16 more bits.
+ * codes now start at bit nbits+16 and end at (nbits+16-codelength) */
+ pos <<= 16;
+ table_mask <<= 16;
+ bit_mask = 1 << 15;
+
+ for (bit_num = nbits+1; bit_num <= HUFF_MAXBITS; bit_num++) {
+ for (sym = 0; sym < nsyms; sym++) {
+ if (length[sym] != bit_num) continue;
+
+#ifdef BITS_ORDER_MSB
+ leaf = pos >> 16;
+#else
+ /* leaf = the first nbits of the code, reversed */
+ reverse = pos >> 16; leaf = 0; fill = nbits;
+ do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill);
+#endif
+ for (fill = 0; fill < (bit_num - nbits); fill++) {
+ /* if this path hasn't been taken yet, 'allocate' two entries */
+ if (table[leaf] == 0xFFFF) {
+ table[(next_symbol << 1) ] = 0xFFFF;
+ table[(next_symbol << 1) + 1 ] = 0xFFFF;
+ table[leaf] = next_symbol++;
+ }
+
+ /* follow the path and select either left or right for next bit */
+ leaf = table[leaf] << 1;
+ if ((pos >> (15-fill)) & 1) leaf++;
+ }
+ table[leaf] = sym;
+
+ if ((pos += bit_mask) > table_mask) return 1; /* table overflow */
+ }
+ bit_mask >>= 1;
+ }
+
+ /* full table? */
+ return (pos == table_mask) ? 0 : 1;
+}
+#endif
diff --git a/rbutil/rbutilqt/mspack/sha.h b/rbutil/rbutilqt/mspack/sha.h
new file mode 100644
index 0000000000..360521519b
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/sha.h
@@ -0,0 +1,15 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_LZSS_H
+#define MSPACK_LZSS_H 1
+
+/* SHA-1 message digest definitions */
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/system.c b/rbutil/rbutilqt/mspack/system.c
new file mode 100644
index 0000000000..f3f0019f5e
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/system.c
@@ -0,0 +1,237 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <system.h>
+
+#ifndef LARGEFILE_SUPPORT
+const char *largefile_msg = "library not compiled to support large files.";
+#endif
+
+
+int mspack_version(int entity) {
+ switch (entity) {
+ /* CHM decoder version 1 -> 2 changes:
+ * - added mschmd_sec_mscompressed::spaninfo
+ * - added mschmd_header::first_pmgl
+ * - added mschmd_header::last_pmgl
+ * - added mschmd_header::chunk_cache;
+ */
+ case MSPACK_VER_MSCHMD:
+ return 2;
+ case MSPACK_VER_LIBRARY:
+ case MSPACK_VER_SYSTEM:
+ case MSPACK_VER_MSCABD:
+ case MSPACK_VER_MSSZDDD:
+ case MSPACK_VER_MSKWAJD:
+ return 1;
+ case MSPACK_VER_MSCABC:
+ case MSPACK_VER_MSCHMC:
+ case MSPACK_VER_MSLITD:
+ case MSPACK_VER_MSLITC:
+ case MSPACK_VER_MSHLPD:
+ case MSPACK_VER_MSHLPC:
+ case MSPACK_VER_MSSZDDC:
+ case MSPACK_VER_MSKWAJC:
+ return 0;
+ }
+ return -1;
+}
+
+int mspack_sys_selftest_internal(int offt_size) {
+ return (sizeof(off_t) == offt_size) ? MSPACK_ERR_OK : MSPACK_ERR_SEEK;
+}
+
+/* validates a system structure */
+int mspack_valid_system(struct mspack_system *sys) {
+ return (sys != NULL) && (sys->open != NULL) && (sys->close != NULL) &&
+ (sys->read != NULL) && (sys->write != NULL) && (sys->seek != NULL) &&
+ (sys->tell != NULL) && (sys->message != NULL) && (sys->alloc != NULL) &&
+ (sys->free != NULL) && (sys->copy != NULL) && (sys->null_ptr == NULL);
+}
+
+/* returns the length of a file opened for reading */
+int mspack_sys_filelen(struct mspack_system *system,
+ struct mspack_file *file, off_t *length)
+{
+ off_t current;
+
+ if (!system || !file || !length) return MSPACK_ERR_OPEN;
+
+ /* get current offset */
+ current = system->tell(file);
+
+ /* seek to end of file */
+ if (system->seek(file, (off_t) 0, MSPACK_SYS_SEEK_END)) {
+ return MSPACK_ERR_SEEK;
+ }
+
+ /* get offset of end of file */
+ *length = system->tell(file);
+
+ /* seek back to original offset */
+ if (system->seek(file, current, MSPACK_SYS_SEEK_START)) {
+ return MSPACK_ERR_SEEK;
+ }
+
+ return MSPACK_ERR_OK;
+}
+
+
+
+/* definition of mspack_default_system -- if the library is compiled with
+ * MSPACK_NO_DEFAULT_SYSTEM, no default system will be provided. Otherwise,
+ * an appropriate default system (e.g. the standard C library, or some native
+ * API calls)
+ */
+
+#ifdef MSPACK_NO_DEFAULT_SYSTEM
+struct mspack_system *mspack_default_system = NULL;
+#else
+
+/* implementation of mspack_default_system for standard C library */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+struct mspack_file_p {
+ FILE *fh;
+ const char *name;
+};
+
+static struct mspack_file *msp_open(struct mspack_system *self,
+ const char *filename, int mode)
+{
+ struct mspack_file_p *fh;
+ const char *fmode;
+
+ switch (mode) {
+ case MSPACK_SYS_OPEN_READ: fmode = "rb"; break;
+ case MSPACK_SYS_OPEN_WRITE: fmode = "wb"; break;
+ case MSPACK_SYS_OPEN_UPDATE: fmode = "r+b"; break;
+ case MSPACK_SYS_OPEN_APPEND: fmode = "ab"; break;
+ default: return NULL;
+ }
+
+ if ((fh = (struct mspack_file_p *) malloc(sizeof(struct mspack_file_p)))) {
+ fh->name = filename;
+ if ((fh->fh = fopen(filename, fmode))) return (struct mspack_file *) fh;
+ free(fh);
+ }
+ return NULL;
+}
+
+static void msp_close(struct mspack_file *file) {
+ struct mspack_file_p *self = (struct mspack_file_p *) file;
+ if (self) {
+ fclose(self->fh);
+ free(self);
+ }
+}
+
+static int msp_read(struct mspack_file *file, void *buffer, int bytes) {
+ struct mspack_file_p *self = (struct mspack_file_p *) file;
+ if (self && buffer && bytes >= 0) {
+ size_t count = fread(buffer, 1, (size_t) bytes, self->fh);
+ if (!ferror(self->fh)) return (int) count;
+ }
+ return -1;
+}
+
+static int msp_write(struct mspack_file *file, void *buffer, int bytes) {
+ struct mspack_file_p *self = (struct mspack_file_p *) file;
+ if (self && buffer && bytes >= 0) {
+ size_t count = fwrite(buffer, 1, (size_t) bytes, self->fh);
+ if (!ferror(self->fh)) return (int) count;
+ }
+ return -1;
+}
+
+static int msp_seek(struct mspack_file *file, off_t offset, int mode) {
+ struct mspack_file_p *self = (struct mspack_file_p *) file;
+ if (self) {
+ switch (mode) {
+ case MSPACK_SYS_SEEK_START: mode = SEEK_SET; break;
+ case MSPACK_SYS_SEEK_CUR: mode = SEEK_CUR; break;
+ case MSPACK_SYS_SEEK_END: mode = SEEK_END; break;
+ default: return -1;
+ }
+#ifdef HAVE_FSEEKO
+ return fseeko(self->fh, offset, mode);
+#else
+ return fseek(self->fh, offset, mode);
+#endif
+ }
+ return -1;
+}
+
+static off_t msp_tell(struct mspack_file *file) {
+ struct mspack_file_p *self = (struct mspack_file_p *) file;
+#ifdef HAVE_FSEEKO
+ return (self) ? (off_t) ftello(self->fh) : 0;
+#else
+ return (self) ? (off_t) ftell(self->fh) : 0;
+#endif
+}
+
+static void msp_msg(struct mspack_file *file, const char *format, ...) {
+ va_list ap;
+ if (file) fprintf(stderr, "%s: ", ((struct mspack_file_p *) file)->name);
+ va_start(ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ fputc((int) '\n', stderr);
+ fflush(stderr);
+}
+
+static void *msp_alloc(struct mspack_system *self, size_t bytes) {
+#ifdef DEBUG
+ /* make uninitialised data obvious */
+ char *buf = malloc(bytes + 8);
+ if (buf) memset(buf, 0xDC, bytes);
+ *((size_t *)buf) = bytes;
+ return &buf[8];
+#else
+ return malloc(bytes);
+#endif
+}
+
+static void msp_free(void *buffer) {
+#ifdef DEBUG
+ char *buf = buffer;
+ size_t bytes;
+ if (buf) {
+ buf -= 8;
+ bytes = *((size_t *)buf);
+ /* make freed data obvious */
+ memset(buf, 0xED, bytes);
+ free(buf);
+ }
+#else
+ free(buffer);
+#endif
+}
+
+static void msp_copy(void *src, void *dest, size_t bytes) {
+ memcpy(dest, src, bytes);
+}
+
+static struct mspack_system msp_system = {
+ &msp_open, &msp_close, &msp_read, &msp_write, &msp_seek,
+ &msp_tell, &msp_msg, &msp_alloc, &msp_free, &msp_copy, NULL
+};
+
+struct mspack_system *mspack_default_system = &msp_system;
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/system.h b/rbutil/rbutilqt/mspack/system.h
new file mode 100644
index 0000000000..4a400850aa
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/system.h
@@ -0,0 +1,124 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_SYSTEM_H
+#define MSPACK_SYSTEM_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ensure config.h is read before mspack.h */
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <mspack.h>
+
+/* fix for problem with GCC 4 and glibc (thanks to Ville Skytta)
+ * http://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=150429
+ */
+#ifdef read
+# undef read
+#endif
+
+#ifdef DEBUG
+# include <stdio.h>
+/* Old GCCs don't have __func__, but __FUNCTION__:
+ * http://gcc.gnu.org/onlinedocs/gcc/Function-Names.html
+ */
+# if __STDC_VERSION__ < 199901L
+# if __GNUC__ >= 2
+# define __func__ __FUNCTION__
+# else
+# define __func__ "<unknown>"
+# endif
+# endif
+# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __func__); \
+ printf x ; fputc('\n', stdout); fflush(stdout);} while (0);
+#else
+# define D(x)
+#endif
+
+/* CAB supports searching through files over 4GB in size, and the CHM file
+ * format actively uses 64-bit offsets. These can only be fully supported
+ * if the system the code runs on supports large files. If not, the library
+ * will work as normal using only 32-bit arithmetic, but if an offset
+ * greater than 2GB is detected, an error message indicating the library
+ * can't support the file should be printed.
+ */
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
+#if ((defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS >= 64) || \
+ (defined(FILESIZEBITS) && FILESIZEBITS >= 64) || \
+ (defined(SIZEOF_OFF_T) && SIZEOF_OFF_T >= 8) || \
+ defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE))
+# define LARGEFILE_SUPPORT
+# define LD "lld"
+# define LU "llu"
+#else
+extern const char *largefile_msg;
+# define LD "ld"
+# define LU "lu"
+#endif
+
+/* endian-neutral reading of little-endian data */
+#define __egi32(a,n) ( ((((unsigned char *) a)[n+3]) << 24) | \
+ ((((unsigned char *) a)[n+2]) << 16) | \
+ ((((unsigned char *) a)[n+1]) << 8) | \
+ ((((unsigned char *) a)[n+0])))
+#define EndGetI64(a) ((((unsigned long long int) __egi32(a,4)) << 32) | \
+ ((unsigned int) __egi32(a,0)))
+#define EndGetI32(a) __egi32(a,0)
+#define EndGetI16(a) ((((a)[1])<<8)|((a)[0]))
+
+/* endian-neutral reading of big-endian data */
+#define EndGetM32(a) (((((unsigned char *) a)[0]) << 24) | \
+ ((((unsigned char *) a)[1]) << 16) | \
+ ((((unsigned char *) a)[2]) << 8) | \
+ ((((unsigned char *) a)[3])))
+#define EndGetM16(a) ((((a)[0])<<8)|((a)[1]))
+
+extern struct mspack_system *mspack_default_system;
+
+/* returns the length of a file opened for reading */
+extern int mspack_sys_filelen(struct mspack_system *system,
+ struct mspack_file *file, off_t *length);
+
+/* validates a system structure */
+extern int mspack_valid_system(struct mspack_system *sys);
+
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+
+#if HAVE_MEMCMP
+# define mspack_memcmp memcmp
+#else
+/* inline memcmp() */
+static inline int mspack_memcmp(const void *s1, const void *s2, size_t n) {
+ unsigned char *c1 = (unsigned char *) s1;
+ unsigned char *c2 = (unsigned char *) s2;
+ if (n == 0) return 0;
+ while (--n && (*c1 == *c2)) c1++, c2++;
+ return *c1 - *c2;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/szdd.h b/rbutil/rbutilqt/mspack/szdd.h
new file mode 100644
index 0000000000..e07c6b7c8e
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/szdd.h
@@ -0,0 +1,39 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+#ifndef MSPACK_SZDD_H
+#define MSPACK_SZDD_H 1
+
+#include <lzss.h>
+
+/* input buffer size during decompression - not worth parameterising IMHO */
+#define SZDD_INPUT_SIZE (2048)
+
+/* SZDD compression definitions */
+
+struct msszdd_compressor_p {
+ struct msszdd_compressor base;
+ struct mspack_system *system;
+ int error;
+};
+
+/* SZDD decompression definitions */
+
+struct msszdd_decompressor_p {
+ struct msszdd_decompressor base;
+ struct mspack_system *system;
+ int error;
+};
+
+struct msszddd_header_p {
+ struct msszddd_header base;
+ struct mspack_file *fh;
+};
+
+#endif
diff --git a/rbutil/rbutilqt/mspack/szddc.c b/rbutil/rbutilqt/mspack/szddc.c
new file mode 100644
index 0000000000..cdd39a6305
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/szddc.c
@@ -0,0 +1,24 @@
+/* This file is part of libmspack.
+ * (C) 2003-2004 Stuart Caie.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* SZDD compression implementation */
+
+#include <system.h>
+#include <szdd.h>
+
+struct msszdd_compressor *
+ mspack_create_szdd_compressor(struct mspack_system *sys)
+{
+ /* todo */
+ return NULL;
+}
+
+void mspack_destroy_szdd_compressor(struct msszdd_compressor *self) {
+ /* todo */
+}
diff --git a/rbutil/rbutilqt/mspack/szddd.c b/rbutil/rbutilqt/mspack/szddd.c
new file mode 100644
index 0000000000..99c5aa4658
--- /dev/null
+++ b/rbutil/rbutilqt/mspack/szddd.c
@@ -0,0 +1,247 @@
+/* This file is part of libmspack.
+ * (C) 2003-2010 Stuart Caie.
+ *
+ * SZDD is a format used in the MS-DOS commands COMPRESS.EXE and
+ * EXPAND.EXE. The compression method is attributed to Steven Zeck,
+ * however it's pretty much identical to LZSS.
+ *
+ * libmspack is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1
+ *
+ * For further details, see the file COPYING.LIB distributed with libmspack
+ */
+
+/* SZDD decompression implementation */
+
+#include <system.h>
+#include <szdd.h>
+
+/* prototypes */
+static struct msszddd_header *szddd_open(
+ struct msszdd_decompressor *base, const char *filename);
+static void szddd_close(
+ struct msszdd_decompressor *base, struct msszddd_header *hdr);
+static int szddd_read_headers(
+ struct mspack_system *sys, struct mspack_file *fh,
+ struct msszddd_header *hdr);
+static int szddd_extract(
+ struct msszdd_decompressor *base, struct msszddd_header *hdr,
+ const char *filename);
+static int szddd_decompress(
+ struct msszdd_decompressor *base, const char *input, const char *output);
+static int szddd_error(
+ struct msszdd_decompressor *base);
+
+/***************************************
+ * MSPACK_CREATE_SZDD_DECOMPRESSOR
+ ***************************************
+ * constructor
+ */
+struct msszdd_decompressor *
+ mspack_create_szdd_decompressor(struct mspack_system *sys)
+{
+ struct msszdd_decompressor_p *self = NULL;
+
+ if (!sys) sys = mspack_default_system;
+ if (!mspack_valid_system(sys)) return NULL;
+
+ if ((self = (struct msszdd_decompressor_p *) sys->alloc(sys, sizeof(struct msszdd_decompressor_p)))) {
+ self->base.open = &szddd_open;
+ self->base.close = &szddd_close;
+ self->base.extract = &szddd_extract;
+ self->base.decompress = &szddd_decompress;
+ self->base.last_error = &szddd_error;
+ self->system = sys;
+ self->error = MSPACK_ERR_OK;
+ }
+ return (struct msszdd_decompressor *) self;
+}
+
+/***************************************
+ * MSPACK_DESTROY_SZDD_DECOMPRESSOR
+ ***************************************
+ * destructor
+ */
+void mspack_destroy_szdd_decompressor(struct msszdd_decompressor *base)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ if (self) {
+ struct mspack_system *sys = self->system;
+ sys->free(self);
+ }
+}
+
+/***************************************
+ * SZDDD_OPEN
+ ***************************************
+ * opens an SZDD file without decompressing, reads header
+ */
+static struct msszddd_header *szddd_open(struct msszdd_decompressor *base,
+ const char *filename)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ struct msszddd_header *hdr;
+ struct mspack_system *sys;
+ struct mspack_file *fh;
+
+ if (!self) return NULL;
+ sys = self->system;
+
+ fh = sys->open(sys, filename, MSPACK_SYS_OPEN_READ);
+ hdr = (struct msszddd_header *) sys->alloc(sys, sizeof(struct msszddd_header_p));
+ if (fh && hdr) {
+ ((struct msszddd_header_p *) hdr)->fh = fh;
+ self->error = szddd_read_headers(sys, fh, hdr);
+ }
+ else {
+ if (!fh) self->error = MSPACK_ERR_OPEN;
+ if (!hdr) self->error = MSPACK_ERR_NOMEMORY;
+ }
+
+ if (self->error) {
+ if (fh) sys->close(fh);
+ if (hdr) sys->free(hdr);
+ hdr = NULL;
+ }
+
+ return hdr;
+}
+
+/***************************************
+ * SZDDD_CLOSE
+ ***************************************
+ * closes an SZDD file
+ */
+static void szddd_close(struct msszdd_decompressor *base,
+ struct msszddd_header *hdr)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ struct msszddd_header_p *hdr_p = (struct msszddd_header_p *) hdr;
+
+ if (!self || !self->system) return;
+
+ /* close the file handle associated */
+ self->system->close(hdr_p->fh);
+
+ /* free the memory associated */
+ self->system->free(hdr);
+
+ self->error = MSPACK_ERR_OK;
+}
+
+/***************************************
+ * SZDDD_READ_HEADERS
+ ***************************************
+ * reads the headers of an SZDD format file
+ */
+static unsigned char szdd_signature_expand[8] = {
+ 0x53, 0x5A, 0x44, 0x44, 0x88, 0xF0, 0x27, 0x33
+};
+static unsigned char szdd_signature_qbasic[8] = {
+ 0x53, 0x5A, 0x20, 0x88, 0xF0, 0x27, 0x33, 0xD1
+};
+
+static int szddd_read_headers(struct mspack_system *sys,
+ struct mspack_file *fh,
+ struct msszddd_header *hdr)
+{
+ unsigned char buf[8];
+
+ /* read and check signature */
+ if (sys->read(fh, buf, 8) != 8) return MSPACK_ERR_READ;
+
+ if ((mspack_memcmp(buf, szdd_signature_expand, 8) == 0)) {
+ /* common SZDD */
+ hdr->format = MSSZDD_FMT_NORMAL;
+
+ /* read the rest of the header */
+ if (sys->read(fh, buf, 6) != 6) return MSPACK_ERR_READ;
+ if (buf[0] != 0x41) return MSPACK_ERR_DATAFORMAT;
+ hdr->missing_char = buf[1];
+ hdr->length = EndGetI32(&buf[2]);
+ }
+ else if ((mspack_memcmp(buf, szdd_signature_qbasic, 8) == 0)) {
+ /* special QBasic SZDD */
+ hdr->format = MSSZDD_FMT_QBASIC;
+ if (sys->read(fh, buf, 4) != 4) return MSPACK_ERR_READ;
+ hdr->missing_char = '\0';
+ hdr->length = EndGetI32(buf);
+ }
+ else {
+ return MSPACK_ERR_SIGNATURE;
+ }
+ return MSPACK_ERR_OK;
+}
+
+/***************************************
+ * SZDDD_EXTRACT
+ ***************************************
+ * decompresses an SZDD file
+ */
+static int szddd_extract(struct msszdd_decompressor *base,
+ struct msszddd_header *hdr, const char *filename)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ struct mspack_file *fh, *outfh;
+ struct mspack_system *sys;
+ off_t data_offset;
+
+ if (!self) return MSPACK_ERR_ARGS;
+ if (!hdr) return self->error = MSPACK_ERR_ARGS;
+ sys = self->system;
+
+ fh = ((struct msszddd_header_p *) hdr)->fh;
+
+ /* seek to the compressed data */
+ data_offset = (hdr->format == MSSZDD_FMT_NORMAL) ? 14 : 12;
+ if (sys->seek(fh, data_offset, MSPACK_SYS_SEEK_START)) {
+ return self->error = MSPACK_ERR_SEEK;
+ }
+
+ /* open file for output */
+ if (!(outfh = sys->open(sys, filename, MSPACK_SYS_OPEN_WRITE))) {
+ return self->error = MSPACK_ERR_OPEN;
+ }
+
+ /* decompress the data */
+ self->error = lzss_decompress(sys, fh, outfh, SZDD_INPUT_SIZE,
+ hdr->format == MSSZDD_FMT_NORMAL
+ ? LZSS_MODE_EXPAND
+ : LZSS_MODE_QBASIC);
+
+ /* close output file */
+ sys->close(outfh);
+
+ return self->error;
+}
+
+/***************************************
+ * SZDDD_DECOMPRESS
+ ***************************************
+ * unpacks directly from input to output
+ */
+static int szddd_decompress(struct msszdd_decompressor *base,
+ const char *input, const char *output)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ struct msszddd_header *hdr;
+ int error;
+
+ if (!self) return MSPACK_ERR_ARGS;
+
+ if (!(hdr = szddd_open(base, input))) return self->error;
+ error = szddd_extract(base, hdr, output);
+ szddd_close(base, hdr);
+ return self->error = error;
+}
+
+/***************************************
+ * SZDDD_ERROR
+ ***************************************
+ * returns the last error that occurred
+ */
+static int szddd_error(struct msszdd_decompressor *base)
+{
+ struct msszdd_decompressor_p *self = (struct msszdd_decompressor_p *) base;
+ return (self) ? self->error : MSPACK_ERR_ARGS;
+}