diff options
40 files changed, 2026 insertions, 2481 deletions
@@ -0,0 +1,13 @@ +msitools are maintained by Paolo Bonzini. <pbonzini@redhat.com> + +libmsi is mostly based on Wine's implementation of Windows Installer, +with the following copyright: + +* Copyright 1999 Patrik Stridvall +* Copyright 2002 Alexandre Julliard +* Copyright 2002-2010 Mike McCormack, Aric Stewart, Robert Shearman, Hans Leidekker + for CodeWeavers +* Copyright 2006 Mike McCormack +* Copyright 2007-2008 James Hawkins +* Copyright 2008 James Hawkins +* Copyright 2011 Bernhard Loos @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/COPYING.LIB b/COPYING.LIB new file mode 100644 index 0000000..ae23fcf --- /dev/null +++ b/COPYING.LIB @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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! + + @@ -0,0 +1,8 @@ +For the time being, development is done in both the Windows +(IStream/IStorage) and portable (libgsf) versions. This is because the +test coverage is slightly worse in the libgsf version---some tests fail +only in that version. + +The pre-gsf branch is developed with the mingw cross-compiler and wine. +The master branch, which uses libgsf, is developed both with mingw+wine +(though some tests fail) and native tools. @@ -0,0 +1,21 @@ +msitools is a set of programs to inspect and build Windows Installer +(.MSI) files. It is based on libmsi, a portable library to read and +write .MSI files. libmsi in turn is a port of (and a subset of) Wine's +implementation of the Windows Installer. + +msitools plans to be a solution for packaging and deployment of +cross-compiled Windows applications. + +While in a very early stage, it is already usable. Two tools are +provided, msiinfo and msibuild, respectively to inspect and create +MSI files. They are very low-level, but it should already be possible +to use these tools to take an existing .MSI file, and update it with +new build products (for example after a cross-compilation). + +msitools uses libgsf in order to read OLE Structured Storage files +(which are the underlying format of .MSI files). As of December 7th, +2012 you need to build libgsf from git because a required bugfix is not +found in any release. Fedora packages for a fixed libgsf can be found +at http://bonzini.fedorapeople.org/. + +For more information, contact me at pbonzini@redhat.com. @@ -0,0 +1,22 @@ +- verify gsf conversion, some tests fail on Windows but not POSIX? +- make a SummaryInformation API that does not suck (including converting + FILETIME usage to GDateTime) +- add an API to open a query and return a pointer to the next SQL + statement in the passed string +- add a SQL tool with readline +- add API to import from a string +- add API to write a stream field to a GIO stream or back +- change Foo** APIs to use GError instead +- change char* APIs to return a dynamically allocated string +- split regression tests into many smaller harnesses, possibly using + gtester +- add tests for msiinfo + +... + +Missing functionality: + +- generating transforms + +Use GLIB 2.22? +- GInitable, GAsync diff --git a/configure.ac b/configure.ac index 4e6fa6a..3ad8966 100644 --- a/configure.ac +++ b/configure.ac @@ -1,4 +1,4 @@ -AC_INIT([msitools], [0.0]) +AC_INIT([msitools], [0.01]) AC_PREREQ([2.64]) AC_CONFIG_HEADERS([config.h]) diff --git a/libmsi/Makefile.am b/libmsi/Makefile.am index 4ce4413..afeefae 100644 --- a/libmsi/Makefile.am +++ b/libmsi/Makefile.am @@ -1,8 +1,7 @@ NULL = lib_LTLIBRARIES = libmsi.la -AM_CPPFLAGS = -I$(top_srcdir)/include -I$(srcdir) -I. -DUNICODE \ - -I$(srcdir)/winstubs -include $(srcdir)/winstubs/winstubs.h \ +AM_CPPFLAGS = -I$(top_srcdir)/include -I$(srcdir) -I. \ $(GLIB_CFLAGS) $(GSF_CFLAGS) $(GOBJECT_CFLAGS) AM_CFLAGS = -Wunused -Wimplicit @@ -34,17 +33,9 @@ libmsi_la_SOURCES = \ tokenize.c \ update.c \ where.c \ - utf16/snprintfW.c \ - utf16/sprintfW.c \ - utf16/strtolW.c \ $(NULL) libmsi_la_LDFLAGS = -no-undefined -rpath $(libdir) \ -export-symbols-regex='^libmsi_' -libmsi_la_LIBADD = \ - $(GLIB_LIBS) \ - $(GSF_LIBS) \ - $(GOBJECT_LIBS) \ - -lshlwapi \ - -lole32 +libmsi_la_LIBADD = $(GLIB_LIBS) $(GSF_LIBS) $(GOBJECT_LIBS) diff --git a/libmsi/alter.c b/libmsi/alter.c index 90b4550..e6e56e6 100644 --- a/libmsi/alter.c +++ b/libmsi/alter.c @@ -20,13 +20,8 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" #include "query.h" @@ -50,7 +45,7 @@ static unsigned alter_view_fetch_int( LibmsiView *view, unsigned row, unsigned c return LIBMSI_RESULT_FUNCTION_FAILED; } -static unsigned alter_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, IStream **stm) +static unsigned alter_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm) { LibmsiAlterView *av = (LibmsiAlterView*)view; @@ -74,18 +69,14 @@ static unsigned count_iter(LibmsiRecord *row, void *param) return LIBMSI_RESULT_SUCCESS; } -static bool check_column_exists(LibmsiDatabase *db, const WCHAR *table, const WCHAR *column) +static bool check_column_exists(LibmsiDatabase *db, const char *table, const char *column) { LibmsiQuery *view; LibmsiRecord *rec; unsigned r; - static const WCHAR query[] = { - 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ', - '`','_','C','o','l','u','m','n','s','`',' ','W','H','E','R','E',' ', - '`','T','a','b','l','e','`','=','\'','%','s','\'',' ','A','N','D',' ', - '`','N','a','m','e','`','=','\'','%','s','\'',0 - }; + static const char query[] = + "SELECT * FROM `_Columns` WHERE `Table`='%s' AND `Name`='%s'"; r = _libmsi_query_open(db, &view, query, table, column); if (r != LIBMSI_RESULT_SUCCESS) @@ -110,13 +101,9 @@ static unsigned alter_add_column(LibmsiAlterView *av) LibmsiQuery *view; LibmsiView *columns; - static const WCHAR szColumns[] = {'_','C','o','l','u','m','n','s',0}; - static const WCHAR query[] = { - 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ', - '`','_','C','o','l','u','m','n','s','`',' ','W','H','E','R','E',' ', - '`','T','a','b','l','e','`','=','\'','%','s','\'',' ','O','R','D','E','R',' ', - 'B','Y',' ','`','N','u','m','b','e','r','`',0 - }; + static const char szColumns[] = "_Columns"; + static const char query[] = + "SELECT * FROM `_Columns` WHERE `Table`='%s' ORDER BY `Number`"; r = table_view_create(av->db, szColumns, &columns); if (r != LIBMSI_RESULT_SUCCESS) @@ -187,8 +174,8 @@ static unsigned alter_view_get_dimensions( LibmsiView *view, unsigned *rows, uns return LIBMSI_RESULT_FUNCTION_FAILED; } -static unsigned alter_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned alter_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiAlterView *av = (LibmsiAlterView*)view; @@ -239,12 +226,12 @@ static const LibmsiViewOps alter_ops = NULL, }; -unsigned alter_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *name, column_info *colinfo, int hold ) +unsigned alter_view_create( LibmsiDatabase *db, LibmsiView **view, const char *name, column_info *colinfo, int hold ) { LibmsiAlterView *av; unsigned r; - TRACE("%p %p %s %d\n", view, colinfo, debugstr_w(name), hold ); + TRACE("%p %p %s %d\n", view, colinfo, debugstr_a(name), hold ); av = msi_alloc_zero( sizeof *av ); if( !av ) diff --git a/libmsi/create.c b/libmsi/create.c index 3cdc576..745a0e1 100644 --- a/libmsi/create.c +++ b/libmsi/create.c @@ -20,16 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -41,7 +34,7 @@ typedef struct _LibmsiCreateView { LibmsiView view; LibmsiDatabase *db; - const WCHAR * name; + const char * name; bool bIsTemp; bool hold; column_info *col_info; @@ -61,7 +54,7 @@ static unsigned create_view_execute( LibmsiView *view, LibmsiRecord *record ) LibmsiCreateView *cv = (LibmsiCreateView*)view; bool persist = (cv->bIsTemp) ? LIBMSI_CONDITION_FALSE : LIBMSI_CONDITION_TRUE; - TRACE("%p Table %s (%s)\n", cv, debugstr_w(cv->name), + TRACE("%p Table %s (%s)\n", cv, debugstr_a(cv->name), cv->bIsTemp?"temporary":"permanent"); if (cv->bIsTemp && !cv->hold) @@ -88,8 +81,8 @@ static unsigned create_view_get_dimensions( LibmsiView *view, unsigned *rows, un return LIBMSI_RESULT_FUNCTION_FAILED; } -static unsigned create_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned create_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiCreateView *cv = (LibmsiCreateView*)view; @@ -139,13 +132,13 @@ static unsigned check_columns( const column_info *col_info ) /* check for two columns with the same name */ for( c1 = col_info; c1; c1 = c1->next ) for( c2 = c1->next; c2; c2 = c2->next ) - if (!strcmpW( c1->column, c2->column )) + if (!strcmp( c1->column, c2->column )) return LIBMSI_RESULT_BAD_QUERY_SYNTAX; return LIBMSI_RESULT_SUCCESS; } -unsigned create_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *table, +unsigned create_view_create( LibmsiDatabase *db, LibmsiView **view, const char *table, column_info *col_info, bool hold ) { LibmsiCreateView *cv = NULL; diff --git a/libmsi/delete.c b/libmsi/delete.c index 9a945c4..3a3623c 100644 --- a/libmsi/delete.c +++ b/libmsi/delete.c @@ -20,15 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -62,7 +56,7 @@ static unsigned delete_view_fetch_int( LibmsiView *view, unsigned row, unsigned return LIBMSI_RESULT_FUNCTION_FAILED; } -static unsigned delete_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, IStream **stm) +static unsigned delete_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm) { LibmsiDeleteView *dv = (LibmsiDeleteView*)view; @@ -124,8 +118,8 @@ static unsigned delete_view_get_dimensions( LibmsiView *view, unsigned *rows, un return dv->table->ops->get_dimensions( dv->table, NULL, cols ); } -static unsigned delete_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned delete_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiDeleteView *dv = (LibmsiDeleteView*)view; diff --git a/libmsi/distinct.c b/libmsi/distinct.c index 80b841f..d134b03 100644 --- a/libmsi/distinct.c +++ b/libmsi/distinct.c @@ -20,15 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -202,8 +196,8 @@ static unsigned distinct_view_get_dimensions( LibmsiView *view, unsigned *rows, return dv->table->ops->get_dimensions( dv->table, NULL, cols ); } -static unsigned distinct_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned distinct_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiDistinctView *dv = (LibmsiDistinctView*)view; diff --git a/libmsi/drop.c b/libmsi/drop.c index 14078bd..2fd2501 100644 --- a/libmsi/drop.c +++ b/libmsi/drop.c @@ -20,13 +20,8 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" #include "query.h" @@ -112,12 +107,12 @@ static const LibmsiViewOps drop_ops = NULL, }; -unsigned drop_view_create(LibmsiDatabase *db, LibmsiView **view, const WCHAR *name) +unsigned drop_view_create(LibmsiDatabase *db, LibmsiView **view, const char *name) { LibmsiDropView *dv; unsigned r; - TRACE("%p %s\n", view, debugstr_w(name)); + TRACE("%p %s\n", view, debugstr_a(name)); dv = msi_alloc_zero(sizeof *dv ); if(!dv) diff --git a/libmsi/insert.c b/libmsi/insert.c index 9192129..1301584 100644 --- a/libmsi/insert.c +++ b/libmsi/insert.c @@ -20,16 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -78,8 +71,8 @@ LibmsiRecord *msi_query_merge_record( unsigned fields, const column_info *vl, Li switch( vl->val->type ) { case EXPR_SVAL: - TRACE("field %d -> %s\n", i, debugstr_w(vl->val->u.sval)); - _libmsi_record_set_stringW( merged, i, vl->val->u.sval ); + TRACE("field %d -> %s\n", i, debugstr_a(vl->val->u.sval)); + libmsi_record_set_string( merged, i, vl->val->u.sval ); break; case EXPR_IVAL: libmsi_record_set_int( merged, i, vl->val->u.ival ); @@ -107,8 +100,8 @@ err: */ static bool msi_columns_in_order(LibmsiInsertView *iv, unsigned col_count) { - const WCHAR *a; - const WCHAR *b; + const char *a; + const char *b; unsigned i; for (i = 1; i <= col_count; i++) @@ -116,7 +109,7 @@ static bool msi_columns_in_order(LibmsiInsertView *iv, unsigned col_count) iv->sv->ops->get_column_info(iv->sv, i, &a, NULL, NULL, NULL); iv->table->ops->get_column_info(iv->table, i, &b, NULL, NULL, NULL); - if (strcmpW( a, b )) return false; + if (strcmp( a, b )) return false; } return true; } @@ -129,8 +122,8 @@ static unsigned msi_arrange_record(LibmsiInsertView *iv, LibmsiRecord **values) LibmsiRecord *padded; unsigned col_count, val_count; unsigned r, i, colidx; - const WCHAR *a; - const WCHAR *b; + const char *a; + const char *b; r = iv->table->ops->get_dimensions(iv->table, NULL, &col_count); if (r != LIBMSI_RESULT_SUCCESS) @@ -161,7 +154,7 @@ static unsigned msi_arrange_record(LibmsiInsertView *iv, LibmsiRecord **values) if (r != LIBMSI_RESULT_SUCCESS) goto err; - if (!strcmpW( a, b )) + if (!strcmp( a, b )) { _libmsi_record_copy_field(*values, colidx, padded, i); break; @@ -278,8 +271,8 @@ static unsigned insert_view_get_dimensions( LibmsiView *view, unsigned *rows, un return sv->ops->get_dimensions( sv, rows, cols ); } -static unsigned insert_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned insert_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiInsertView *iv = (LibmsiInsertView*)view; LibmsiView *sv; @@ -348,7 +341,7 @@ static unsigned count_column_info( const column_info *ci ) return n; } -unsigned insert_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *table, +unsigned insert_view_create( LibmsiDatabase *db, LibmsiView **view, const char *table, column_info *columns, column_info *values, bool temp ) { LibmsiInsertView *iv = NULL; diff --git a/libmsi/libmsi-database.c b/libmsi/libmsi-database.c index ce85457..6b9f25f 100644 --- a/libmsi/libmsi-database.c +++ b/libmsi/libmsi-database.c @@ -24,21 +24,11 @@ #include <fcntl.h> #include <sys/stat.h> -#define COBJMACROS -#define NONAMELESSUNION - -#include "windef.h" -#include "winbase.h" -#include "winnls.h" - #include "libmsi-database.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" #include "msipriv.h" -#include "objidl.h" -#include "objbase.h" #include "query.h" enum @@ -72,19 +62,19 @@ const char clsid_msi_patch[16] = { 0x86, 0x10, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x0 typedef struct _LibmsiTransform { struct list entry; - IStorage *stg; + GsfInfile *stg; } LibmsiTransform; typedef struct _LibmsiStorage { struct list entry; - WCHAR *name; - IStorage *stg; + char *name; + GsfInfile *stg; } LibmsiStorage; typedef struct _LibmsiStream { struct list entry; - WCHAR *name; - IStream *stm; + char *name; + GsfInput *stm; } LibmsiStream; static void @@ -213,86 +203,33 @@ libmsi_database_class_init (LibmsiDatabaseClass *klass) G_PARAM_STATIC_STRINGS)); } -static HRESULT stream_to_storage(IStream *stm, IStorage **stg) -{ - ILockBytes *lockbytes = NULL; - STATSTG stat; - void *data; - HRESULT hr; - unsigned size, read; - ULARGE_INTEGER offset; - - hr = IStream_Stat(stm, &stat, STATFLAG_NONAME); - if (FAILED(hr)) - return hr; - - if (stat.cbSize.QuadPart >> 32) - { - ERR("Storage is too large\n"); - return E_FAIL; - } - - size = stat.cbSize.QuadPart; - data = msi_alloc(size); - if (!data) - return E_OUTOFMEMORY; - - hr = IStream_Read(stm, data, size, &read); - if (FAILED(hr) || read != size) - goto done; - - hr = CreateILockBytesOnHGlobal(NULL, true, &lockbytes); - if (FAILED(hr)) - goto done; - - ZeroMemory(&offset, sizeof(ULARGE_INTEGER)); - hr = ILockBytes_WriteAt(lockbytes, offset, data, size, &read); - if (FAILED(hr) || read != size) - goto done; - - hr = StgOpenStorageOnILockBytes(lockbytes, NULL, - STGM_READWRITE | STGM_SHARE_DENY_NONE, - NULL, 0, stg); - if (FAILED(hr)) - goto done; - -done: - msi_free(data); - if (lockbytes) ILockBytes_Release(lockbytes); - return hr; -} - -unsigned msi_open_storage( LibmsiDatabase *db, const WCHAR *stname ) +unsigned msi_open_storage( LibmsiDatabase *db, const char *stname ) { - unsigned r; - HRESULT hr; + unsigned r = LIBMSI_RESULT_NOT_ENOUGH_MEMORY; LibmsiStorage *storage; + GsfInput *in; LIST_FOR_EACH_ENTRY( storage, &db->storages, LibmsiStorage, entry ) { - if( !strcmpW( stname, storage->name ) ) + if( !strcmp( stname, storage->name ) ) { - TRACE("found %s\n", debugstr_w(stname)); + TRACE("found %s\n", debugstr_a(stname)); return; } } if (!(storage = msi_alloc_zero( sizeof(LibmsiStorage) ))) return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - storage->name = strdupW( stname ); + storage->name = strdup( stname ); if (!storage->name) - { - r = LIBMSI_RESULT_NOT_ENOUGH_MEMORY; goto done; - } - hr = IStorage_OpenStorage(db->infile, stname, NULL, - STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0, - &storage->stg); - if (FAILED(hr)) - { - r = LIBMSI_RESULT_FUNCTION_FAILED; + in = gsf_infile_child_by_name(db->infile, stname); + if (!GSF_IS_INFILE(in)) + goto done; + + storage->stg = GSF_INFILE(in); + if (!storage->stg) goto done; - } list_add_tail( &db->storages, &storage->entry ); r = LIBMSI_RESULT_SUCCESS; @@ -306,12 +243,11 @@ done: return r; } -unsigned msi_create_storage( LibmsiDatabase *db, const WCHAR *stname, IStream *stm ) +unsigned msi_create_storage( LibmsiDatabase *db, const char *stname, GsfInput *stm ) { LibmsiStorage *storage; - IStorage *origstg = NULL; + GsfInfile *origstg = NULL; bool found = false; - HRESULT hr; unsigned r; if ( db->mode == LIBMSI_DB_OPEN_READONLY ) @@ -319,9 +255,9 @@ unsigned msi_create_storage( LibmsiDatabase *db, const WCHAR *stname, IStream *s LIST_FOR_EACH_ENTRY( storage, &db->storages, LibmsiStorage, entry ) { - if( !strcmpW( stname, storage->name ) ) + if( !strcmp( stname, storage->name ) ) { - TRACE("found %s\n", debugstr_w(stname)); + TRACE("found %s\n", debugstr_a(stname)); found = true; break; } @@ -329,7 +265,7 @@ unsigned msi_create_storage( LibmsiDatabase *db, const WCHAR *stname, IStream *s if (!found) { if (!(storage = msi_alloc_zero( sizeof(LibmsiStorage) ))) return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - storage->name = strdupW( stname ); + storage->name = strdup( stname ); if (!storage->name) { msi_free(storage); @@ -337,19 +273,19 @@ unsigned msi_create_storage( LibmsiDatabase *db, const WCHAR *stname, IStream *s } } - r = stream_to_storage(stm, &origstg); - if (r != LIBMSI_RESULT_SUCCESS) + origstg = gsf_infile_msole_new(stm, NULL); + if (origstg == NULL) goto done; if (found) { if (storage->stg) - IStorage_Release(storage->stg); + g_object_unref(G_OBJECT(storage->stg)); } else { list_add_tail( &db->storages, &storage->entry ); } storage->stg = origstg; - IStorage_AddRef(storage->stg); + g_object_ref(G_OBJECT(storage->stg)); r = LIBMSI_RESULT_SUCCESS; @@ -362,38 +298,38 @@ done: } if (origstg) - IStorage_Release(origstg); + g_object_unref(G_OBJECT(origstg)); return r; } -void msi_destroy_storage( LibmsiDatabase *db, const WCHAR *stname ) +void msi_destroy_storage( LibmsiDatabase *db, const char *stname ) { LibmsiStorage *storage, *storage2; LIST_FOR_EACH_ENTRY_SAFE( storage, storage2, &db->storages, LibmsiStorage, entry ) { - if (!strcmpW( stname, storage->name )) + if (!strcmp( stname, storage->name )) { - TRACE("destroying %s\n", debugstr_w(stname)); + TRACE("destroying %s\n", debugstr_a(stname)); list_remove( &storage->entry ); - IStorage_Release( storage->stg ); + g_object_unref(G_OBJECT(storage->stg)); msi_free( storage ); break; } } } -static unsigned find_infile_stream( LibmsiDatabase *db, const WCHAR *name, IStream **stm ) +static unsigned find_infile_stream( LibmsiDatabase *db, const char *name, GsfInput **stm ) { LibmsiStream *stream; LIST_FOR_EACH_ENTRY( stream, &db->streams, LibmsiStream, entry ) { - if( !strcmpW( name, stream->name ) ) + if( !strcmp( name, stream->name ) ) { - TRACE("found %s\n", debugstr_w(name)); + TRACE("found %s\n", debugstr_a(name)); *stm = stream->stm; return LIBMSI_RESULT_SUCCESS; } @@ -402,69 +338,56 @@ static unsigned find_infile_stream( LibmsiDatabase *db, const WCHAR *name, IStre return LIBMSI_RESULT_FUNCTION_FAILED; } -static unsigned msi_alloc_stream( LibmsiDatabase *db, const WCHAR *stname, IStream *stm) +static unsigned msi_alloc_stream( LibmsiDatabase *db, const char *stname, GsfInput *stm) { LibmsiStream *stream; - TRACE("%p %s %p", db, debugstr_w(stname), stm); + TRACE("%p %s %p", db, debugstr_a(stname), stm); if (!(stream = msi_alloc( sizeof(LibmsiStream) ))) return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - stream->name = strdupW( stname ); + stream->name = strdup( stname ); stream->stm = stm; - IStream_AddRef( stm ); + g_object_ref(G_OBJECT(stm)); list_add_tail( &db->streams, &stream->entry ); return LIBMSI_RESULT_SUCCESS; } -unsigned write_raw_stream_data( LibmsiDatabase *db, const WCHAR *stname, - const void *data, unsigned sz, IStream **outstm ) +unsigned write_raw_stream_data( LibmsiDatabase *db, const char *stname, + const void *data, unsigned sz, GsfInput **outstm ) { - HRESULT r; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - unsigned count; - IStream *stm = NULL; - HANDLE hGlob; + GsfInput *stm = NULL; + char *mem; LibmsiStream *stream; - ULARGE_INTEGER size; if (db->mode == LIBMSI_DB_OPEN_READONLY) return LIBMSI_RESULT_FUNCTION_FAILED; LIST_FOR_EACH_ENTRY( stream, &db->streams, LibmsiStream, entry ) { - if( !strcmpW( stname, stream->name ) ) + if( !strcmp( stname, stream->name ) ) { msi_destroy_stream( db, stname ); break; } } - hGlob = GlobalAlloc(GMEM_FIXED, sz); - if (!hGlob) + mem = g_try_malloc(sz == 0 ? 1 : sz); + if (!mem) return LIBMSI_RESULT_FUNCTION_FAILED; if (data || sz) - memcpy(hGlob, data, sz); - - r = CreateStreamOnHGlobal(hGlob, true, &stm); - if( FAILED( r ) ) - { - GlobalFree(hGlob); - return LIBMSI_RESULT_FUNCTION_FAILED; - } - - /* set the correct size - CreateStreamOnHGlobal screws it up */ - size.QuadPart = sz; - IStream_SetSize(stm, size); + memcpy(mem, data, sz); + stm = gsf_input_memory_new(mem, sz, true); ret = msi_alloc_stream( db, stname, stm); *outstm = stm; return ret; } -unsigned msi_create_stream( LibmsiDatabase *db, const WCHAR *stname, IStream *stm ) +unsigned msi_create_stream( LibmsiDatabase *db, const char *stname, GsfInput *stm ) { LibmsiStream *stream; - WCHAR *encname = NULL; + char *encname = NULL; unsigned r = LIBMSI_RESULT_FUNCTION_FAILED; bool found = false; @@ -475,7 +398,7 @@ unsigned msi_create_stream( LibmsiDatabase *db, const WCHAR *stname, IStream *st LIST_FOR_EACH_ENTRY( stream, &db->streams, LibmsiStream, entry ) { - if( !strcmpW( encname, stream->name ) ) + if( !strcmp( encname, stream->name ) ) { found = true; break; @@ -484,18 +407,19 @@ unsigned msi_create_stream( LibmsiDatabase *db, const WCHAR *stname, IStream *st if (found) { if (stream->stm) - IStream_Release(stream->stm); + g_object_unref(G_OBJECT(stream->stm)); stream->stm = stm; - IStream_AddRef(stream->stm); + g_object_ref(G_OBJECT(stream->stm)); r = LIBMSI_RESULT_SUCCESS; } else r = msi_alloc_stream( db, encname, stm ); + msi_free(encname); return r; } unsigned msi_enum_db_streams(LibmsiDatabase *db, - unsigned (*fn)(const WCHAR *, IStream *, void *), + unsigned (*fn)(const char *, GsfInput *, void *), void *opaque) { unsigned r; @@ -503,12 +427,12 @@ unsigned msi_enum_db_streams(LibmsiDatabase *db, LIST_FOR_EACH_ENTRY_SAFE( stream, stream2, &db->streams, LibmsiStream, entry ) { - IStream *stm; + GsfInput *stm; stm = stream->stm; - IStream_AddRef(stm); + g_object_ref(G_OBJECT(stm)); r = fn( stream->name, stm, opaque); - IStream_Release(stm); + g_object_unref(G_OBJECT(stm)); if (r) { return r; @@ -519,7 +443,7 @@ unsigned msi_enum_db_streams(LibmsiDatabase *db, } unsigned msi_enum_db_storages(LibmsiDatabase *db, - unsigned (*fn)(const WCHAR *, IStorage *, void *), + unsigned (*fn)(const char *, GsfInfile *, void *), void *opaque) { unsigned r; @@ -527,12 +451,12 @@ unsigned msi_enum_db_storages(LibmsiDatabase *db, LIST_FOR_EACH_ENTRY_SAFE( storage, storage2, &db->storages, LibmsiStorage, entry ) { - IStorage *stg; + GsfInfile *stg; stg = storage->stg; - IStorage_AddRef(stg); + g_object_ref(G_OBJECT(stg)); r = fn( storage->name, stg, opaque); - IStorage_Release(stg); + g_object_unref(G_OBJECT(stg)); if (r) { return r; @@ -542,71 +466,64 @@ unsigned msi_enum_db_storages(LibmsiDatabase *db, return LIBMSI_RESULT_SUCCESS; } -unsigned clone_infile_stream( LibmsiDatabase *db, const WCHAR *name, IStream **stm ) +unsigned clone_infile_stream( LibmsiDatabase *db, const char *name, GsfInput **stm ) { - IStream *stream; + GsfInput *stream; if (find_infile_stream( db, name, &stream ) == LIBMSI_RESULT_SUCCESS) { - HRESULT r; - LARGE_INTEGER pos; - - r = IStream_Clone( stream, stm ); - if( FAILED( r ) ) + stream = gsf_input_dup( stream, NULL ); + if( !stream ) { - WARN("failed to clone stream r = %08x!\n", r); - return LIBMSI_RESULT_FUNCTION_FAILED; - } - - pos.QuadPart = 0; - r = IStream_Seek( *stm, pos, STREAM_SEEK_SET, NULL ); - if( FAILED( r ) ) - { - IStream_Release( *stm ); + WARN("failed to clone stream\n"); return LIBMSI_RESULT_FUNCTION_FAILED; } + gsf_input_seek( stream, 0, G_SEEK_SET ); + *stm = stream; return LIBMSI_RESULT_SUCCESS; } return LIBMSI_RESULT_FUNCTION_FAILED; } -unsigned msi_get_raw_stream( LibmsiDatabase *db, const WCHAR *stname, IStream **stm ) +unsigned msi_get_raw_stream( LibmsiDatabase *db, const char *stname, GsfInput **stm ) { - HRESULT r; - WCHAR decoded[MAX_STREAM_NAME_LEN]; + unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; + char decoded[MAX_STREAM_NAME_LEN]; LibmsiTransform *transform; decode_streamname( stname, decoded ); - TRACE("%s -> %s\n", debugstr_w(stname), debugstr_w(decoded)); + TRACE("%s -> %s\n", debugstr_a(stname), debugstr_a(decoded)); if (clone_infile_stream( db, stname, stm ) == LIBMSI_RESULT_SUCCESS) return LIBMSI_RESULT_SUCCESS; LIST_FOR_EACH_ENTRY( transform, &db->transforms, LibmsiTransform, entry ) { - r = IStorage_OpenStream( transform->stg, stname, NULL, - STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm ); - if (SUCCEEDED(r)) - return LIBMSI_RESULT_SUCCESS; + *stm = gsf_infile_child_by_name( transform->stg, stname ); + if (*stm) + { + ret = LIBMSI_RESULT_SUCCESS; + break; + } } - return LIBMSI_RESULT_FUNCTION_FAILED; + return ret; } -void msi_destroy_stream( LibmsiDatabase *db, const WCHAR *stname ) +void msi_destroy_stream( LibmsiDatabase *db, const char *stname ) { LibmsiStream *stream, *stream2; LIST_FOR_EACH_ENTRY_SAFE( stream, stream2, &db->streams, LibmsiStream, entry ) { - if (!strcmpW( stname, stream->name )) + if (!strcmp( stname, stream->name )) { - TRACE("destroying %s\n", debugstr_w(stname)); + TRACE("destroying %s\n", debugstr_a(stname)); list_remove( &stream->entry ); - IStream_Release( stream->stm ); + g_object_unref(G_OBJECT(stream->stm)); msi_free( stream ); break; } @@ -619,7 +536,7 @@ static void free_storages( LibmsiDatabase *db ) { LibmsiStorage *s = LIST_ENTRY(list_head( &db->storages ), LibmsiStorage, entry); list_remove( &s->entry ); - IStorage_Release( s->stg ); + g_object_unref(G_OBJECT(s->stg)); msi_free( s->name ); msi_free( s ); } @@ -631,19 +548,19 @@ static void free_streams( LibmsiDatabase *db ) { LibmsiStream *s = LIST_ENTRY(list_head( &db->streams ), LibmsiStream, entry); list_remove( &s->entry ); - IStream_Release( s->stm ); + g_object_unref(G_OBJECT(s->stm)); msi_free( s->name ); msi_free( s ); } } -void append_storage_to_db( LibmsiDatabase *db, IStorage *stg ) +void append_storage_to_db( LibmsiDatabase *db, GsfInfile *stg ) { LibmsiTransform *t; t = msi_alloc( sizeof *t ); t->stg = stg; - IStorage_AddRef( stg ); + g_object_ref(G_OBJECT(t->stg)); list_add_head( &db->transforms, &t->entry ); #if 0 @@ -667,13 +584,14 @@ LibmsiResult _libmsi_database_close(LibmsiDatabase *db, bool committed) if ( db->infile ) { - IStorage_Release( db->infile ); + g_object_unref(G_OBJECT(db->infile)); db->infile = NULL; } if ( db->outfile ) { - IStorage_Release( db->outfile ); + gsf_output_close(GSF_OUTPUT(db->outfile)); + g_object_unref(G_OBJECT(db->outfile)); db->outfile = NULL; } free_streams( db ); @@ -698,11 +616,10 @@ LibmsiResult _libmsi_database_close(LibmsiDatabase *db, bool committed) LibmsiResult _libmsi_database_start_transaction(LibmsiDatabase *db) { unsigned ret = LIBMSI_RESULT_SUCCESS; - IStorage *stg = NULL; - WCHAR *szwPersist; + GsfOutput *out; + GsfOutfile *stg = NULL; char *tmpfile = NULL; char path[PATH_MAX]; - HRESULT hr; if( db->mode == LIBMSI_DB_OPEN_READONLY ) return LIBMSI_RESULT_SUCCESS; @@ -721,33 +638,40 @@ LibmsiResult _libmsi_database_start_transaction(LibmsiDatabase *db) TRACE("%p %s\n", db, szPersist); - szwPersist = strdupAtoW(db->outpath); - hr = StgCreateDocfile( szwPersist, - STGM_CREATE|STGM_TRANSACTED|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &stg ); - - msi_free(szwPersist); - - if ( SUCCEEDED(hr) ) - hr = IStorage_SetClass( stg, db->patch ? &clsid_msi_patch : &clsid_msi_database ); + out = gsf_output_stdio_new(db->outpath, NULL); + if (!out) + { + WARN("open file failed for %s\n", debugstr_a(db->outpath)); + return LIBMSI_RESULT_OPEN_FAILED; + } + stg = gsf_outfile_msole_new(out); + g_object_unref(G_OBJECT(out)); + if (!stg) + { + WARN("open failed for %s\n", debugstr_a(db->outpath)); + return LIBMSI_RESULT_OPEN_FAILED; + } - if( FAILED( hr ) ) + if (!gsf_outfile_msole_set_class_id(GSF_OUTFILE_MSOLE(stg), + db->patch ? clsid_msi_patch : clsid_msi_database )) { - WARN("open failed hr = %08x for %s\n", hr, debugstr_a(db->outpath)); + WARN("set guid failed\n"); ret = LIBMSI_RESULT_FUNCTION_FAILED; goto end; } db->outfile = stg; - IStorage_AddRef( db->outfile ); + g_object_ref(G_OBJECT(db->outfile)); end: if (ret) { if (db->outfile) - IStorage_Release( db->outfile ); + g_object_unref(G_OBJECT(db->outfile)); db->outfile = NULL; } if (stg) - IStorage_Release( stg ); + g_object_unref(G_OBJECT(stg)); + msi_free(tmpfile); return ret; } @@ -760,10 +684,10 @@ LibmsiResult libmsi_database_open(const char *szDBPath, const char *szPersist, L if( !pdb ) return LIBMSI_RESULT_INVALID_PARAMETER; - if (!strchr( szDBPath, '\\' )) + if (!strstr( szDBPath, G_DIR_SEPARATOR_S )) { getcwd( path, MAX_PATH ); - strcat( path, "\\" ); + strcat( path, G_DIR_SEPARATOR_S ); strcat( path, szDBPath ); } else @@ -774,43 +698,23 @@ LibmsiResult libmsi_database_open(const char *szDBPath, const char *szPersist, L return *pdb ? LIBMSI_RESULT_SUCCESS : LIBMSI_RESULT_OPEN_FAILED; } -static WCHAR *msi_read_text_archive(const char *path, unsigned *len) +static char *msi_read_text_archive(const char *path, unsigned *len) { - int fd; - struct stat st; - char *data = NULL; - WCHAR *wdata = NULL; - ssize_t nread; + char *data; + size_t nread; - /* TODO g_file_get_contents */ - fd = open( path, O_RDONLY | O_BINARY); - if (fd == -1) + if (!g_file_get_contents(path, &data, &nread, NULL)) return NULL; - fstat (fd, &st); - if (!(data = msi_alloc( st.st_size ))) goto done; - - nread = read(fd, data, st.st_size); - if (nread != st.st_size) goto done; - - while (!data[st.st_size - 1]) st.st_size--; - *len = MultiByteToWideChar( CP_ACP, 0, data, st.st_size, NULL, 0 ); - if ((wdata = msi_alloc( (*len + 1) * sizeof(WCHAR) ))) - { - MultiByteToWideChar( CP_ACP, 0, data, st.st_size, wdata, *len ); - wdata[*len] = 0; - } - -done: - close( fd ); - msi_free( data ); - return wdata; + while (!data[nread - 1]) nread--; + *len = nread; + return data; } -static void msi_parse_line(WCHAR **line, WCHAR ***entries, unsigned *num_entries, unsigned *len) +static void msi_parse_line(char **line, char ***entries, unsigned *num_entries, unsigned *len) { - WCHAR *ptr = *line; - WCHAR *save; + char *ptr = *line; + char *save; unsigned i, count = 1, chars_left = *len; *entries = NULL; @@ -826,7 +730,7 @@ static void msi_parse_line(WCHAR **line, WCHAR ***entries, unsigned *num_entries chars_left--; } - *entries = msi_alloc(count * sizeof(WCHAR *)); + *entries = msi_alloc(count * sizeof(char *)); if (!*entries) return; @@ -877,41 +781,41 @@ static void msi_parse_line(WCHAR **line, WCHAR ***entries, unsigned *num_entries *num_entries = count; } -static WCHAR *msi_build_createsql_prelude(WCHAR *table) +static char *msi_build_createsql_prelude(char *table) { - WCHAR *prelude; + char *prelude; unsigned size; - static const WCHAR create_fmt[] = {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','%','s','`',' ','(',' ',0}; + static const char create_fmt[] = "CREATE TABLE `%s` ("; - size = sizeof(create_fmt)/sizeof(create_fmt[0]) + strlenW(table) - 2; - prelude = msi_alloc(size * sizeof(WCHAR)); + size = sizeof(create_fmt)/sizeof(create_fmt[0]) + strlen(table) - 2; + prelude = msi_alloc(size * sizeof(char)); if (!prelude) return NULL; - sprintfW(prelude, create_fmt, table); + sprintf(prelude, create_fmt, table); return prelude; } -static WCHAR *msi_build_createsql_columns(WCHAR **columns_data, WCHAR **types, unsigned num_columns) +static char *msi_build_createsql_columns(char **columns_data, char **types, unsigned num_columns) { - WCHAR *columns; - WCHAR *p; - const WCHAR *type; + char *columns; + char *p; + const char *type; unsigned sql_size = 1, i, len; - WCHAR expanded[128], *ptr; - WCHAR size[10], comma[2], extra[30]; - - static const WCHAR column_fmt[] = {'`','%','s','`',' ','%','s','%','s','%','s','%','s',' ',0}; - static const WCHAR size_fmt[] = {'(','%','s',')',0}; - static const WCHAR type_char[] = {'C','H','A','R',0}; - static const WCHAR type_int[] = {'I','N','T',0}; - static const WCHAR type_long[] = {'L','O','N','G',0}; - static const WCHAR type_object[] = {'O','B','J','E','C','T',0}; - static const WCHAR type_notnull[] = {' ','N','O','T',' ','N','U','L','L',0}; - static const WCHAR localizable[] = {' ','L','O','C','A','L','I','Z','A','B','L','E',0}; - - columns = msi_alloc_zero(sql_size * sizeof(WCHAR)); + char expanded[128], *ptr; + char size[10], comma[2], extra[30]; + + static const char column_fmt[] = "`%s` %s%s%s%s "; + static const char size_fmt[] = "(%s)"; + static const char type_char[] = "CHAR"; + static const char type_int[] = "INT"; + static const char type_long[] = "LONG"; + static const char type_object[] = "OBJECT"; + static const char type_notnull[] = " NOT NULL"; + static const char localizable[] = " LOCALIZABLE"; + + columns = msi_alloc_zero(sql_size * sizeof(char)); if (!columns) return NULL; @@ -926,28 +830,28 @@ static WCHAR *msi_build_createsql_columns(WCHAR **columns_data, WCHAR **types, u comma[0] = ','; ptr = &types[i][1]; - len = atolW(ptr); + len = atol(ptr); extra[0] = '\0'; switch (types[i][0]) { case 'l': - strcpyW(extra, type_notnull); + strcpy(extra, type_notnull); /* fall through */ case 'L': - strcatW(extra, localizable); + strcat(extra, localizable); type = type_char; - sprintfW(size, size_fmt, ptr); + sprintf(size, size_fmt, ptr); break; case 's': - strcpyW(extra, type_notnull); + strcpy(extra, type_notnull); /* fall through */ case 'S': type = type_char; - sprintfW(size, size_fmt, ptr); + sprintf(size, size_fmt, ptr); break; case 'i': - strcpyW(extra, type_notnull); + strcpy(extra, type_notnull); /* fall through */ case 'I': if (len <= 2) @@ -962,7 +866,7 @@ static WCHAR *msi_build_createsql_columns(WCHAR **columns_data, WCHAR **types, u } break; case 'v': - strcpyW(extra, type_notnull); + strcpy(extra, type_notnull); /* fall through */ case 'V': type = type_object; @@ -973,10 +877,10 @@ static WCHAR *msi_build_createsql_columns(WCHAR **columns_data, WCHAR **types, u return NULL; } - sprintfW(expanded, column_fmt, columns_data[i], type, size, extra, comma); - sql_size += strlenW(expanded); + sprintf(expanded, column_fmt, columns_data[i], type, size, extra, comma); + sql_size += strlen(expanded); - p = msi_realloc(columns, sql_size * sizeof(WCHAR)); + p = msi_realloc(columns, sql_size * sizeof(char)); if (!p) { msi_free(columns); @@ -984,60 +888,60 @@ static WCHAR *msi_build_createsql_columns(WCHAR **columns_data, WCHAR **types, u } columns = p; - strcatW(columns, expanded); + strcat(columns, expanded); } return columns; } -static WCHAR *msi_build_createsql_postlude(WCHAR **primary_keys, unsigned num_keys) +static char *msi_build_createsql_postlude(char **primary_keys, unsigned num_keys) { - WCHAR *postlude; - WCHAR *keys; - WCHAR *ptr; + char *postlude; + char *keys; + char *ptr; unsigned size, key_size, i; - static const WCHAR key_fmt[] = {'`','%','s','`',',',' ',0}; - static const WCHAR postlude_fmt[] = {'P','R','I','M','A','R','Y',' ','K','E','Y',' ','%','s',')',0}; + static const char key_fmt[] = "`%s`, "; + static const char postlude_fmt[] = "PRIMARY KEY %s)"; for (i = 0, size = 1; i < num_keys; i++) - size += strlenW(key_fmt) + strlenW(primary_keys[i]) - 2; + size += strlen(key_fmt) + strlen(primary_keys[i]) - 2; - keys = msi_alloc(size * sizeof(WCHAR)); + keys = msi_alloc(size * sizeof(char)); if (!keys) return NULL; for (i = 0, ptr = keys; i < num_keys; i++) { - key_size = strlenW(key_fmt) + strlenW(primary_keys[i]) -2; - sprintfW(ptr, key_fmt, primary_keys[i]); + key_size = strlen(key_fmt) + strlen(primary_keys[i]) -2; + sprintf(ptr, key_fmt, primary_keys[i]); ptr += key_size; } /* remove final ', ' */ *(ptr - 2) = '\0'; - size = strlenW(postlude_fmt) + size - 1; - postlude = msi_alloc(size * sizeof(WCHAR)); + size = strlen(postlude_fmt) + size - 1; + postlude = msi_alloc(size * sizeof(char)); if (!postlude) goto done; - sprintfW(postlude, postlude_fmt, keys); + sprintf(postlude, postlude_fmt, keys); done: msi_free(keys); return postlude; } -static unsigned msi_add_table_to_db(LibmsiDatabase *db, WCHAR **columns, WCHAR **types, WCHAR **labels, unsigned num_labels, unsigned num_columns) +static unsigned msi_add_table_to_db(LibmsiDatabase *db, char **columns, char **types, char **labels, unsigned num_labels, unsigned num_columns) { unsigned r = LIBMSI_RESULT_OUTOFMEMORY; unsigned size; LibmsiQuery *view; - WCHAR *create_sql = NULL; - WCHAR *prelude; - WCHAR *columns_sql; - WCHAR *postlude; + char *create_sql = NULL; + char *prelude; + char *columns_sql; + char *postlude; prelude = msi_build_createsql_prelude(labels[0]); columns_sql = msi_build_createsql_columns(columns, types, num_columns); @@ -1046,14 +950,14 @@ static unsigned msi_add_table_to_db(LibmsiDatabase *db, WCHAR **columns, WCHAR * if (!prelude || !columns_sql || !postlude) goto done; - size = strlenW(prelude) + strlenW(columns_sql) + strlenW(postlude) + 1; - create_sql = msi_alloc(size * sizeof(WCHAR)); + size = strlen(prelude) + strlen(columns_sql) + strlen(postlude) + 1; + create_sql = msi_alloc(size * sizeof(char)); if (!create_sql) goto done; - strcpyW(create_sql, prelude); - strcatW(create_sql, columns_sql); - strcatW(create_sql, postlude); + strcpy(create_sql, prelude); + strcat(create_sql, columns_sql); + strcat(create_sql, postlude); r = _libmsi_database_open_query( db, create_sql, &view ); if (r != LIBMSI_RESULT_SUCCESS) @@ -1071,14 +975,13 @@ done: return r; } -static char *msi_import_stream_filename(const char *path, const WCHAR *name) +static char *msi_import_stream_filename(const char *path, const char *name) { unsigned len; - char *ascii_name = strdupWtoA(name); char *fullname; char *ptr; - len = strlen(path) + strlen(ascii_name) + 1; + len = strlen(path) + strlen(name) + 1; fullname = msi_alloc(len); if (!fullname) return NULL; @@ -1092,14 +995,13 @@ static char *msi_import_stream_filename(const char *path, const WCHAR *name) msi_free (fullname); return NULL; } - *ptr++ = '\\'; - strcpy( ptr, ascii_name ); - msi_free( ascii_name ); + strcpy( ptr, G_DIR_SEPARATOR_S ); + strcat( ptr, name ); return fullname; } -static unsigned construct_record(unsigned num_columns, WCHAR **types, - WCHAR **data, const char *path, LibmsiRecord **rec) +static unsigned construct_record(unsigned num_columns, char **types, + char **data, const char *path, LibmsiRecord **rec) { unsigned i; @@ -1112,11 +1014,11 @@ static unsigned construct_record(unsigned num_columns, WCHAR **types, switch (types[i][0]) { case 'L': case 'l': case 'S': case 's': - _libmsi_record_set_stringW(*rec, i + 1, data[i]); + libmsi_record_set_string(*rec, i + 1, data[i]); break; case 'I': case 'i': if (*data[i]) - libmsi_record_set_int(*rec, i + 1, atoiW(data[i])); + libmsi_record_set_int(*rec, i + 1, atoi(data[i])); break; case 'V': case 'v': if (*data[i]) @@ -1142,8 +1044,8 @@ static unsigned construct_record(unsigned num_columns, WCHAR **types, return LIBMSI_RESULT_SUCCESS; } -static unsigned msi_add_records_to_table(LibmsiDatabase *db, WCHAR **columns, WCHAR **types, - WCHAR **labels, WCHAR ***records, +static unsigned msi_add_records_to_table(LibmsiDatabase *db, char **columns, char **types, + char **labels, char ***records, int num_columns, int num_records, const char *path) { @@ -1197,18 +1099,16 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, unsigned num_columns = 0; unsigned num_records = 0; char *path = NULL; - WCHAR **columns = NULL; - WCHAR **types = NULL; - WCHAR **labels = NULL; - WCHAR *ptr; - WCHAR *data = NULL; - WCHAR ***records = NULL; - WCHAR ***temp_records; - - static const WCHAR suminfo[] = - {'_','S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0}; - static const WCHAR forcecodepage[] = - {'_','F','o','r','c','e','C','o','d','e','p','a','g','e',0}; + char **columns = NULL; + char **types = NULL; + char **labels = NULL; + char *ptr; + char *data = NULL; + char ***records = NULL; + char ***temp_records; + + static const char suminfo[] = "_SummaryInformation"; + static const char forcecodepage[] = "_ForceCodepage"; TRACE("%p %s %s\n", db, debugstr_a(folder), debugstr_a(file) ); @@ -1221,7 +1121,7 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, return LIBMSI_RESULT_OUTOFMEMORY; strcpy( path, folder ); - strcat( path, "\\" ); + strcat( path, G_DIR_SEPARATOR_S ); strcat( path, file ); data = msi_read_text_archive( path, &len ); @@ -1234,9 +1134,9 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, msi_parse_line( &ptr, &labels, &num_labels, &len ); if (num_columns == 1 && !columns[0][0] && num_labels == 1 && !labels[0][0] && - num_types == 2 && !strcmpW( types[1], forcecodepage )) + num_types == 2 && !strcmp( types[1], forcecodepage )) { - r = msi_set_string_table_codepage( db->strings, atoiW( types[0] ) ); + r = msi_set_string_table_codepage( db->strings, atoi( types[0] ) ); goto done; } @@ -1246,7 +1146,7 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, goto done; } - records = msi_alloc(sizeof(WCHAR **)); + records = msi_alloc(sizeof(char **)); if (!records) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -1259,7 +1159,7 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, msi_parse_line( &ptr, &records[num_records], NULL, &len ); num_records++; - temp_records = msi_realloc(records, (num_records + 1) * sizeof(WCHAR **)); + temp_records = msi_realloc(records, (num_records + 1) * sizeof(char **)); if (!temp_records) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -1268,7 +1168,7 @@ static unsigned _libmsi_database_import(LibmsiDatabase *db, const char *folder, records = temp_records; } - if (!strcmpW(labels[0], suminfo)) + if (!strcmp(labels[0], suminfo)) { r = msi_add_suminfo( db, records, num_records, num_columns ); if (r != LIBMSI_RESULT_SUCCESS) @@ -1390,20 +1290,18 @@ static unsigned msi_export_forcecodepage( int fd, unsigned codepage ) return LIBMSI_RESULT_SUCCESS; } -static unsigned _libmsi_database_export( LibmsiDatabase *db, const WCHAR *table, +static unsigned _libmsi_database_export( LibmsiDatabase *db, const char *table, int fd) { - static const WCHAR query[] = { - 's','e','l','e','c','t',' ','*',' ','f','r','o','m',' ','%','s',0 }; - static const WCHAR forcecodepage[] = { - '_','F','o','r','c','e','C','o','d','e','p','a','g','e',0 }; + static const char query[] = "select * from %s"; + static const char forcecodepage[] = "_ForceCodepage"; LibmsiRecord *rec = NULL; LibmsiQuery *view = NULL; unsigned r; - TRACE("%p %s %d\n", db, debugstr_w(table), fd ); + TRACE("%p %s %d\n", db, debugstr_a(table), fd ); - if (!strcmpW( table, forcecodepage )) + if (!strcmp( table, forcecodepage )) { unsigned codepage = msi_get_string_table_codepage( db->strings ); r = msi_export_forcecodepage( fd, codepage ); @@ -1433,7 +1331,7 @@ static unsigned _libmsi_database_export( LibmsiDatabase *db, const WCHAR *table, r = _libmsi_database_get_primary_keys( db, table, &rec ); if (r == LIBMSI_RESULT_SUCCESS) { - _libmsi_record_set_stringW( rec, 0, table ); + libmsi_record_set_string( rec, 0, table ); msi_export_record( fd, rec, 0 ); g_object_unref(rec); } @@ -1448,7 +1346,7 @@ done: } /*********************************************************************** - * MsiExportDatabaseW [MSI.@] + * MsiExportDatabase [MSI.@] * * Writes a file containing the table data as tab separated ASCII. * @@ -1465,27 +1363,16 @@ done: LibmsiResult libmsi_database_export( LibmsiDatabase *db, const char *szTable, int fd ) { - WCHAR *table = NULL; unsigned r = LIBMSI_RESULT_OUTOFMEMORY; TRACE("%x %s %d\n", db, debugstr_a(szTable), fd); - if( szTable ) - { - table = strdupAtoW( szTable ); - if( !table ) - goto end; - } - if( !db ) return LIBMSI_RESULT_INVALID_HANDLE; g_object_ref(db); - r = _libmsi_database_export( db, table, fd ); + r = _libmsi_database_export( db, szTable, fd ); g_object_unref(db); - -end: - msi_free(table); return r; } @@ -1493,13 +1380,13 @@ typedef struct _tagMERGETABLE { struct list entry; struct list rows; - WCHAR *name; + char *name; unsigned numconflicts; - WCHAR **columns; + char **columns; unsigned numcolumns; - WCHAR **types; + char **types; unsigned numtypes; - WCHAR **labels; + char **labels; unsigned numlabels; } MERGETABLE; @@ -1518,7 +1405,7 @@ typedef struct _tagMERGEDATA struct list *tabledata; } MERGEDATA; -static bool merge_type_match(const WCHAR *type1, const WCHAR *type2) +static bool merge_type_match(const char *type1, const char *type2) { if (((type1[0] == 'l') || (type1[0] == 's')) && ((type2[0] == 'l') || (type2[0] == 's'))) @@ -1528,7 +1415,7 @@ static bool merge_type_match(const WCHAR *type1, const WCHAR *type2) ((type2[0] == 'L') || (type2[0] == 'S'))) return true; - return !strcmpW( type1, type2 ); + return !strcmp( type1, type2 ); } static unsigned merge_verify_colnames(LibmsiQuery *dbview, LibmsiQuery *mergeview) @@ -1550,7 +1437,7 @@ static unsigned merge_verify_colnames(LibmsiQuery *dbview, LibmsiQuery *mergevie if (!_libmsi_record_get_string_raw(mergerec, i)) break; - if (strcmpW( _libmsi_record_get_string_raw( dbrec, i ), _libmsi_record_get_string_raw( mergerec, i ) )) + if (strcmp( _libmsi_record_get_string_raw( dbrec, i ), _libmsi_record_get_string_raw( mergerec, i ) )) { r = LIBMSI_RESULT_DATATYPE_MISMATCH; goto done; @@ -1591,7 +1478,7 @@ done: } static unsigned merge_verify_primary_keys(LibmsiDatabase *db, LibmsiDatabase *mergedb, - const WCHAR *table) + const char *table) { LibmsiRecord *dbrec, *mergerec = NULL; unsigned r, i, count; @@ -1613,7 +1500,7 @@ static unsigned merge_verify_primary_keys(LibmsiDatabase *db, LibmsiDatabase *me for (i = 1; i <= count; i++) { - if (strcmpW( _libmsi_record_get_string_raw( dbrec, i ), _libmsi_record_get_string_raw( mergerec, i ) )) + if (strcmp( _libmsi_record_get_string_raw( dbrec, i ), _libmsi_record_get_string_raw( mergerec, i ) )) { r = LIBMSI_RESULT_DATATYPE_MISMATCH; goto done; @@ -1627,11 +1514,11 @@ done: return r; } -static WCHAR *get_key_value(LibmsiQuery *view, const WCHAR *key, LibmsiRecord *rec) +static char *get_key_value(LibmsiQuery *view, const char *key, LibmsiRecord *rec) { LibmsiRecord *colnames; - WCHAR *str; - WCHAR *val; + char *str; + char *val; unsigned r, i = 0, sz = 0; int cmp; @@ -1642,13 +1529,13 @@ static WCHAR *get_key_value(LibmsiQuery *view, const WCHAR *key, LibmsiRecord *r do { str = msi_dup_record_field(colnames, ++i); - cmp = strcmpW( key, str ); + cmp = strcmp( key, str ); msi_free(str); } while (cmp); g_object_unref(colnames); - r = _libmsi_record_get_stringW(rec, i, NULL, &sz); + r = _libmsi_record_get_string(rec, i, NULL, &sz); if (r != LIBMSI_RESULT_SUCCESS) return NULL; sz++; @@ -1656,24 +1543,24 @@ static WCHAR *get_key_value(LibmsiQuery *view, const WCHAR *key, LibmsiRecord *r if (_libmsi_record_get_string_raw(rec, i)) /* check record field is a string */ { /* quote string record fields */ - const WCHAR szQuote[] = {'\'', 0}; + const char szQuote[] = "'"; sz += 2; - val = msi_alloc(sz*sizeof(WCHAR)); + val = msi_alloc(sz*sizeof(char)); if (!val) return NULL; - strcpyW(val, szQuote); - r = _libmsi_record_get_stringW(rec, i, val+1, &sz); - strcpyW(val+1+sz, szQuote); + strcpy(val, szQuote); + r = _libmsi_record_get_string(rec, i, val+1, &sz); + strcpy(val+1+sz, szQuote); } else { /* do not quote integer record fields */ - val = msi_alloc(sz*sizeof(WCHAR)); + val = msi_alloc(sz*sizeof(char)); if (!val) return NULL; - r = _libmsi_record_get_stringW(rec, i, val, &sz); + r = _libmsi_record_get_string(rec, i, val, &sz); } if (r != LIBMSI_RESULT_SUCCESS) @@ -1686,31 +1573,27 @@ static WCHAR *get_key_value(LibmsiQuery *view, const WCHAR *key, LibmsiRecord *r return val; } -static WCHAR *create_diff_row_query(LibmsiDatabase *merge, LibmsiQuery *view, - WCHAR *table, LibmsiRecord *rec) +static char *create_diff_row_query(LibmsiDatabase *merge, LibmsiQuery *view, + char *table, LibmsiRecord *rec) { - WCHAR *query = NULL; - WCHAR *clause = NULL; - WCHAR *val; - const WCHAR *setptr; - const WCHAR *key; + char *query = NULL; + char *clause = NULL; + char *val; + const char *setptr; + const char *key; unsigned size, oldsize; LibmsiRecord *keys; unsigned r, i, count; - static const WCHAR keyset[] = { - '`','%','s','`',' ','=',' ','%','s',' ','A','N','D',' ',0}; - static const WCHAR lastkeyset[] = { - '`','%','s','`',' ','=',' ','%','s',' ',0}; - static const WCHAR fmt[] = {'S','E','L','E','C','T',' ','*',' ', - 'F','R','O','M',' ','`','%','s','`',' ', - 'W','H','E','R','E',' ','%','s',0}; + static const char keyset[] = "`%s` = %s AND"; + static const char lastkeyset[] = "`%s` = %s "; + static const char fmt[] = "SELECT * FROM %s WHERE %s"; r = _libmsi_database_get_primary_keys(merge, table, &keys); if (r != LIBMSI_RESULT_SUCCESS) return NULL; - clause = msi_alloc_zero(sizeof(WCHAR)); + clause = msi_alloc_zero(sizeof(char)); if (!clause) goto done; @@ -1727,24 +1610,24 @@ static WCHAR *create_diff_row_query(LibmsiDatabase *merge, LibmsiQuery *view, setptr = keyset; oldsize = size; - size += strlenW(setptr) + strlenW(key) + strlenW(val) - 4; - clause = msi_realloc(clause, size * sizeof (WCHAR)); + size += strlen(setptr) + strlen(key) + strlen(val) - 4; + clause = msi_realloc(clause, size * sizeof (char)); if (!clause) { msi_free(val); goto done; } - sprintfW(clause + oldsize - 1, setptr, key, val); + sprintf(clause + oldsize - 1, setptr, key, val); msi_free(val); } - size = strlenW(fmt) + strlenW(table) + strlenW(clause) + 1; - query = msi_alloc(size * sizeof(WCHAR)); + size = strlen(fmt) + strlen(table) + strlen(clause) + 1; + query = msi_alloc(size * sizeof(char)); if (!query) goto done; - sprintfW(query, fmt, table, clause); + sprintf(query, fmt, table, clause); done: msi_free(clause); @@ -1759,7 +1642,7 @@ static unsigned merge_diff_row(LibmsiRecord *rec, void *param) MERGEROW *mergerow; LibmsiQuery *dbview = NULL; LibmsiRecord *row = NULL; - WCHAR *query = NULL; + char *query = NULL; unsigned r = LIBMSI_RESULT_SUCCESS; if (table_view_exists(data->db, table->name)) @@ -1812,7 +1695,7 @@ done: return r; } -static unsigned msi_get_table_labels(LibmsiDatabase *db, const WCHAR *table, WCHAR ***labels, unsigned *numlabels) +static unsigned msi_get_table_labels(LibmsiDatabase *db, const char *table, char ***labels, unsigned *numlabels) { unsigned r, i, count; LibmsiRecord *prec = NULL; @@ -1823,17 +1706,17 @@ static unsigned msi_get_table_labels(LibmsiDatabase *db, const WCHAR *table, WCH count = libmsi_record_get_field_count(prec); *numlabels = count + 1; - *labels = msi_alloc((*numlabels)*sizeof(WCHAR *)); + *labels = msi_alloc((*numlabels)*sizeof(char *)); if (!*labels) { r = LIBMSI_RESULT_OUTOFMEMORY; goto end; } - (*labels)[0] = strdupW(table); + (*labels)[0] = strdup(table); for (i=1; i<=count; i++ ) { - (*labels)[i] = strdupW(_libmsi_record_get_string_raw(prec, i)); + (*labels)[i] = strdup(_libmsi_record_get_string_raw(prec, i)); } end: @@ -1841,7 +1724,7 @@ end: return r; } -static unsigned msi_get_query_columns(LibmsiQuery *query, WCHAR ***columns, unsigned *numcolumns) +static unsigned msi_get_query_columns(LibmsiQuery *query, char ***columns, unsigned *numcolumns) { unsigned r, i, count; LibmsiRecord *prec = NULL; @@ -1851,7 +1734,7 @@ static unsigned msi_get_query_columns(LibmsiQuery *query, WCHAR ***columns, unsi return r; count = libmsi_record_get_field_count(prec); - *columns = msi_alloc(count*sizeof(WCHAR *)); + *columns = msi_alloc(count*sizeof(char *)); if (!*columns) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -1860,7 +1743,7 @@ static unsigned msi_get_query_columns(LibmsiQuery *query, WCHAR ***columns, unsi for (i=1; i<=count; i++ ) { - (*columns)[i-1] = strdupW(_libmsi_record_get_string_raw(prec, i)); + (*columns)[i-1] = strdup(_libmsi_record_get_string_raw(prec, i)); } *numcolumns = count; @@ -1870,7 +1753,7 @@ end: return r; } -static unsigned msi_get_query_types(LibmsiQuery *query, WCHAR ***types, unsigned *numtypes) +static unsigned msi_get_query_types(LibmsiQuery *query, char ***types, unsigned *numtypes) { unsigned r, i, count; LibmsiRecord *prec = NULL; @@ -1880,7 +1763,7 @@ static unsigned msi_get_query_types(LibmsiQuery *query, WCHAR ***types, unsigned return r; count = libmsi_record_get_field_count(prec); - *types = msi_alloc(count*sizeof(WCHAR *)); + *types = msi_alloc(count*sizeof(char *)); if (!*types) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -1890,7 +1773,7 @@ static unsigned msi_get_query_types(LibmsiQuery *query, WCHAR ***types, unsigned *numtypes = count; for (i=1; i<=count; i++ ) { - (*types)[i-1] = strdupW(_libmsi_record_get_string_raw(prec, i)); + (*types)[i-1] = strdup(_libmsi_record_get_string_raw(prec, i)); } end: @@ -1946,14 +1829,13 @@ static void free_merge_table(MERGETABLE *table) msi_free(table); } -static unsigned msi_get_merge_table (LibmsiDatabase *db, const WCHAR *name, MERGETABLE **ptable) +static unsigned msi_get_merge_table (LibmsiDatabase *db, const char *name, MERGETABLE **ptable) { unsigned r; MERGETABLE *table; LibmsiQuery *mergeview = NULL; - static const WCHAR query[] = {'S','E','L','E','C','T',' ','*',' ', - 'F','R','O','M',' ','`','%','s','`',0}; + static const char query[] = "SELECT * FROM %s"; table = msi_alloc_zero(sizeof(MERGETABLE)); if (!table) @@ -1980,7 +1862,7 @@ static unsigned msi_get_merge_table (LibmsiDatabase *db, const WCHAR *name, MERG list_init(&table->rows); - table->name = strdupW(name); + table->name = strdup(name); table->numconflicts = 0; g_object_unref(mergeview); @@ -2000,11 +1882,10 @@ static unsigned merge_diff_tables(LibmsiRecord *rec, void *param) MERGETABLE *table; LibmsiQuery *dbview = NULL; LibmsiQuery *mergeview = NULL; - const WCHAR *name; + const char *name; unsigned r; - static const WCHAR query[] = {'S','E','L','E','C','T',' ','*',' ', - 'F','R','O','M',' ','`','%','s','`',0}; + static const char query[] = "SELECT * FROM %s"; name = _libmsi_record_get_string_raw(rec, 1); @@ -2051,9 +1932,7 @@ done: static unsigned gather_merge_data(LibmsiDatabase *db, LibmsiDatabase *merge, struct list *tabledata) { - static const WCHAR query[] = { - 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ', - '`','_','T','a','b','l','e','s','`',0}; + static const char query[] = "SELECT * FROM _Tables"; LibmsiQuery *view; MERGEDATA data; unsigned r; @@ -2100,26 +1979,17 @@ static unsigned merge_table(LibmsiDatabase *db, MERGETABLE *table) return LIBMSI_RESULT_SUCCESS; } -static unsigned update_merge_errors(LibmsiDatabase *db, const WCHAR *error, - WCHAR *table, unsigned numconflicts) +static unsigned update_merge_errors(LibmsiDatabase *db, const char *error, + char *table, unsigned numconflicts) { unsigned r; LibmsiQuery *view; - static const WCHAR create[] = { - 'C','R','E','A','T','E',' ','T','A','B','L','E',' ', - '`','%','s','`',' ','(','`','T','a','b','l','e','`',' ', - 'C','H','A','R','(','2','5','5',')',' ','N','O','T',' ', - 'N','U','L','L',',',' ','`','N','u','m','R','o','w','M','e','r','g','e', - 'C','o','n','f','l','i','c','t','s','`',' ','S','H','O','R','T',' ', - 'N','O','T',' ','N','U','L','L',' ','P','R','I','M','A','R','Y',' ', - 'K','E','Y',' ','`','T','a','b','l','e','`',')',0}; - static const WCHAR insert[] = { - 'I','N','S','E','R','T',' ','I','N','T','O',' ', - '`','%','s','`',' ','(','`','T','a','b','l','e','`',',',' ', - '`','N','u','m','R','o','w','M','e','r','g','e', - 'C','o','n','f','l','i','c','t','s','`',')',' ','V','A','L','U','E','S', - ' ','(','\'','%','s','\'',',',' ','%','d',')',0}; + static const char create[] = + "CREATE TABLE `%s` (`Table` CHAR(255) NOT NULL, " + "`NumRowMergeConflicts` SHORT NOT NULL PRIMARY KEY `Table`)"; + static const char insert[] = + "INSERT INTO `%s` (`Table`, `NumRowMergeConflicts`) VALUES ('%s', %d)"; if (!table_view_exists(db, error)) { @@ -2147,7 +2017,6 @@ LibmsiResult libmsi_database_merge(LibmsiDatabase *db, LibmsiDatabase *merge, { struct list tabledata = LIST_INIT(tabledata); struct list *item, *cursor; - WCHAR *szwTableName; MERGETABLE *table; bool conflicts; unsigned r; @@ -2161,7 +2030,6 @@ LibmsiResult libmsi_database_merge(LibmsiDatabase *db, LibmsiDatabase *merge, if (!db || !merge) return LIBMSI_RESULT_INVALID_HANDLE; - szwTableName = strdupAtoW(szTableName); g_object_ref(db); g_object_ref(merge); r = gather_merge_data(db, merge, &tabledata); @@ -2175,7 +2043,7 @@ LibmsiResult libmsi_database_merge(LibmsiDatabase *db, LibmsiDatabase *merge, { conflicts = true; - r = update_merge_errors(db, szwTableName, table->name, + r = update_merge_errors(db, szTableName, table->name, table->numconflicts); if (r != LIBMSI_RESULT_SUCCESS) break; @@ -2223,105 +2091,90 @@ LibmsiDBState libmsi_database_get_state( LibmsiDatabase *db ) static void cache_infile_structure( LibmsiDatabase *db ) { - IEnumSTATSTG *stgenum = NULL; - STATSTG stat; - IStream *stream; - HRESULT hr; - unsigned r, size; - WCHAR decname[0x40]; + int i, n; + char decname[0x40]; + unsigned r; - hr = IStorage_EnumElements(db->infile, 0, NULL, 0, &stgenum); - if (FAILED(hr)) - return; + n = gsf_infile_num_children(db->infile); /* TODO: error handling */ - while (true) + for (i = 0; i < n; i++) { - size = 0; - hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size); - if (FAILED(hr) || !size) - break; + GsfInput *in = gsf_infile_child_by_index(db->infile, i); + const uint8_t *name = (const uint8_t *) gsf_input_name(in); /* table streams are not in the _Streams table */ - if (stat.type == STGTY_STREAM) { - if (*stat.pwcsName == 0x4840) + if (!GSF_IS_INFILE(in) || gsf_infile_num_children(GSF_INFILE(in)) == -1) { + /* UTF-8 encoding of 0x4840. */ + if (name[0] == 0xe4 && name[1] == 0xa1 && name[2] == 0x80) { - decode_streamname( stat.pwcsName + 1, decname ); - if ( !strcmpW( decname, szStringPool ) || - !strcmpW( decname, szStringData ) ) - { - CoTaskMemFree(stat.pwcsName); + decode_streamname( name + 3, decname ); + if ( !strcmp( decname, szStringPool ) || + !strcmp( decname, szStringData ) ) continue; - } r = _libmsi_open_table( db, decname, false ); } else { - hr = IStorage_OpenStream( db->infile, stat.pwcsName, NULL, - STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream ); - if ( SUCCEEDED(hr) ) { - r = msi_alloc_stream(db, stat.pwcsName, stream); - IStream_Release(stream); - } + r = msi_alloc_stream(db, name, GSF_INPUT(in)); + g_object_unref(G_OBJECT(in)); } } else { - msi_open_storage(db, stat.pwcsName); + msi_open_storage(db, name); } - CoTaskMemFree(stat.pwcsName); } - - IEnumSTATSTG_Release(stgenum); } LibmsiResult _libmsi_database_open(LibmsiDatabase *db) { - WCHAR *szwDBPath; - HRESULT hr; - STATSTG stat; - IStorage *stg; + GsfInput *in; + GsfInfile *stg; + uint8_t uuid[16]; unsigned ret = LIBMSI_RESULT_OPEN_FAILED; TRACE("%p %s\n", db, db->path); - szwDBPath = strdupAtoW(db->path); - hr = StgOpenStorage( szwDBPath, NULL, - STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg); - msi_free(szwDBPath); - - if( FAILED( hr ) ) + in = gsf_input_stdio_new(db->path, NULL); + if (!in) { - WARN("open failed hr = %08x for %s\n", hr, debugstr_a(db->path)); + WARN("open file failed for %s\n", debugstr_a(db->path)); + return LIBMSI_RESULT_OPEN_FAILED; + } + stg = gsf_infile_msole_new( in, NULL ); + g_object_unref(G_OBJECT(in)); + if( !stg ) + { + WARN("open failed for %s\n", debugstr_a(db->path)); return LIBMSI_RESULT_OPEN_FAILED; } - hr = IStorage_Stat( stg, &stat, STATFLAG_NONAME ); - if( FAILED( hr ) ) + if( !gsf_infile_msole_get_class_id (GSF_INFILE_MSOLE(stg), uuid)) { FIXME("Failed to stat storage\n"); goto end; } - if ( memcmp( &stat.clsid, &clsid_msi_database, 16 ) != 0 && - memcmp( &stat.clsid, &clsid_msi_patch, 16 ) != 0 && - memcmp( &stat.clsid, &clsid_msi_transform, 16 ) != 0 ) + if ( memcmp( uuid, clsid_msi_database, 16 ) != 0 && + memcmp( uuid, clsid_msi_patch, 16 ) != 0 && + memcmp( uuid, clsid_msi_transform, 16 ) != 0 ) { ERR("storage GUID is not a MSI database GUID %s\n", - debugstr_guid(&stat.clsid) ); + debugstr_guid(uuid) ); goto end; } - if ( db->patch && memcmp( &stat.clsid, &clsid_msi_patch, 16 ) != 0 ) + if ( db->patch && memcmp( uuid, clsid_msi_patch, 16 ) != 0 ) { ERR("storage GUID is not the MSI patch GUID %s\n", - debugstr_guid(&stat.clsid) ); + debugstr_guid(uuid) ); goto end; } db->infile = stg; - IStorage_AddRef( db->infile ); + g_object_ref(G_OBJECT(db->infile)); cache_infile_structure( db ); @@ -2333,39 +2186,38 @@ LibmsiResult _libmsi_database_open(LibmsiDatabase *db) end: if (ret) { if (db->infile) - IStorage_Release( db->infile ); + g_object_unref(G_OBJECT(db->infile)); db->infile = NULL; } - IStorage_Release( stg ); + g_object_unref(G_OBJECT(stg)); return ret; } unsigned _libmsi_database_apply_transform( LibmsiDatabase *db, const char *szTransformFile, int iErrorCond ) { - HRESULT r; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - IStorage *stg = NULL; - STATSTG stat; - WCHAR *szwTransformFile = NULL; + GsfInput *in; + GsfInfile *stg; + uint8_t uuid[16]; TRACE("%p %s %d\n", db, debugstr_a(szTransformFile), iErrorCond); - szwTransformFile = strdupAtoW(szTransformFile); - if (!szwTransformFile) goto end; - - r = StgOpenStorage( szwTransformFile, NULL, - STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg); - if ( FAILED(r) ) + in = gsf_input_stdio_new(szTransformFile, NULL); + if (!in) { - WARN("failed to open transform 0x%08x\n", r); - return ret; + WARN("open file failed for transform %s\n", debugstr_a(szTransformFile)); + return LIBMSI_RESULT_OPEN_FAILED; } + stg = gsf_infile_msole_new( in, NULL ); + g_object_unref(G_OBJECT(in)); - r = IStorage_Stat( stg, &stat, STATFLAG_NONAME ); - if ( FAILED( r ) ) + if( !gsf_infile_msole_get_class_id (GSF_INFILE_MSOLE(stg), uuid)) + { + FIXME("Failed to stat storage\n"); goto end; + } - if ( memcmp( &stat.clsid, &clsid_msi_transform, 16 ) != 0 ) + if ( memcmp( uuid, clsid_msi_transform, 16 ) != 0 ) goto end; if( TRACE_ON( msi ) ) @@ -2374,8 +2226,7 @@ unsigned _libmsi_database_apply_transform( LibmsiDatabase *db, ret = msi_table_apply_transform( db, stg ); end: - msi_free(szwTransformFile); - IStorage_Release( stg ); + g_object_unref(G_OBJECT(stg)); return ret; } @@ -2393,65 +2244,79 @@ LibmsiResult libmsi_database_apply_transform( LibmsiDatabase *db, return r; } -static unsigned commit_storage( const WCHAR *name, IStorage *stg, void *opaque) +static int gsf_infile_copy(GsfInfile *inf, GsfOutfile *outf) +{ + int n = gsf_infile_num_children(inf); + int i; + + for (i = 0; i < n; i++) { + const char *name = gsf_infile_name_by_index(inf, i); + GsfInput *child = gsf_infile_child_by_index(inf, i); + GsfInfile *childf = GSF_IS_INFILE (child) ? GSF_INFILE (child) : NULL; + gboolean is_dir = childf && gsf_infile_num_children (childf) > 0; + GsfOutput *dest = gsf_outfile_new_child(outf, name, is_dir); + gboolean ok; + + if (is_dir) + ok = gsf_infile_copy(childf, GSF_OUTFILE(dest)); + else + ok = gsf_input_copy(child, dest); + + g_object_unref(G_OBJECT(child)); + g_object_unref(G_OBJECT(dest)); + if (!ok) + return false; + } + return true; +} + +static unsigned commit_storage( const char *name, GsfInfile *stg, void *opaque) { LibmsiDatabase *db = opaque; - IStorage *outstg; + GsfOutfile *outstg; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - HRESULT r; - TRACE("%s %p %p\n", debugstr_w(name), stg, opaque); + TRACE("%s %p %p\n", debugstr_a(name), stg, opaque); - r = IStorage_CreateStorage( db->outfile, name, - STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &outstg); - if ( FAILED(r) ) + outstg = GSF_OUTFILE(gsf_outfile_new_child( db->outfile, name, true )); + if ( !outstg ) return LIBMSI_RESULT_FUNCTION_FAILED; - r = IStorage_CopyTo( stg, 0, NULL, NULL, outstg ); - if ( FAILED(r) ) + if ( !gsf_infile_copy( stg, outstg ) ) goto end; ret = LIBMSI_RESULT_SUCCESS; end: - IStorage_Release(outstg); + gsf_output_close(GSF_OUTPUT(outstg)); + g_object_unref(G_OBJECT(outstg)); return ret; } -static unsigned commit_stream( const WCHAR *name, IStream *stm, void *opaque) +static unsigned commit_stream( const char *name, GsfInput *stm, void *opaque) { LibmsiDatabase *db = opaque; - STATSTG stat; - IStream *outstm; - ULARGE_INTEGER cbRead, cbWritten; + GsfOutput *outstm; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - HRESULT r; - WCHAR decname[0x40]; + char decname[0x40]; decode_streamname(name, decname); - TRACE("%s(%s) %p %p\n", debugstr_w(name), debugstr_w(decname), stm, opaque); + TRACE("%s(%s) %p %p\n", debugstr_a(name), debugstr_a(decname), stm, opaque); - IStream_Stat(stm, &stat, STATFLAG_NONAME); - r = IStorage_CreateStream( db->outfile, name, - STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &outstm); - if ( FAILED(r) ) + outstm = gsf_outfile_new_child( db->outfile, name, false ); + if ( !outstm ) return LIBMSI_RESULT_FUNCTION_FAILED; - IStream_SetSize( outstm, stat.cbSize ); - - r = IStream_CopyTo( stm, outstm, stat.cbSize, &cbRead, &cbWritten ); - if ( FAILED(r) ) - goto end; - - if (cbRead.QuadPart != stat.cbSize.QuadPart) - goto end; - if (cbWritten.QuadPart != stat.cbSize.QuadPart) + gsf_input_seek (stm, 0, G_SEEK_SET); + gsf_output_seek (outstm, 0, G_SEEK_SET); + if ( !gsf_input_copy( stm, outstm )) goto end; ret = LIBMSI_RESULT_SUCCESS; end: - IStream_Release(outstm); + gsf_output_close(GSF_OUTPUT(outstm)); + g_object_unref(G_OBJECT(outstm)); return ret; } @@ -2459,7 +2324,6 @@ LibmsiResult libmsi_database_commit( LibmsiDatabase *db ) { unsigned r = LIBMSI_RESULT_SUCCESS; unsigned bytes_per_strref; - HRESULT hr; TRACE("%d\n", db); @@ -2504,14 +2368,6 @@ LibmsiResult libmsi_database_commit( LibmsiDatabase *db ) /* FIXME: unlock the database */ - hr = IStorage_Commit( db->outfile, 0 ); - if (FAILED( hr )) - { - WARN("failed to commit changes 0x%08x\n", hr); - r = LIBMSI_RESULT_FUNCTION_FAILED; - goto end; - } - _libmsi_database_close(db, true); db->mode = LIBMSI_DB_OPEN_TRANSACT; _libmsi_database_open(db); @@ -2532,8 +2388,8 @@ struct msi_primary_key_record_info static unsigned msi_primary_key_iterator( LibmsiRecord *rec, void *param ) { struct msi_primary_key_record_info *info = param; - const WCHAR *name; - const WCHAR *table; + const char *name; + const char *table; unsigned type; type = libmsi_record_get_integer( rec, 4 ); @@ -2545,11 +2401,11 @@ static unsigned msi_primary_key_iterator( LibmsiRecord *rec, void *param ) if ( info->n == 1 ) { table = _libmsi_record_get_string_raw( rec, 1 ); - _libmsi_record_set_stringW( info->rec, 0, table); + libmsi_record_set_string( info->rec, 0, table); } name = _libmsi_record_get_string_raw( rec, 3 ); - _libmsi_record_set_stringW( info->rec, info->n, name ); + libmsi_record_set_string( info->rec, info->n, name ); } } @@ -2557,13 +2413,9 @@ static unsigned msi_primary_key_iterator( LibmsiRecord *rec, void *param ) } unsigned _libmsi_database_get_primary_keys( LibmsiDatabase *db, - const WCHAR *table, LibmsiRecord **prec ) + const char *table, LibmsiRecord **prec ) { - static const WCHAR sql[] = { - 's','e','l','e','c','t',' ','*',' ', - 'f','r','o','m',' ','`','_','C','o','l','u','m','n','s','`',' ', - 'w','h','e','r','e',' ', - '`','T','a','b','l','e','`',' ','=',' ','\'','%','s','\'',0 }; + static const char sql[] = "select * from `_Columns` where `Table` = '%s'"; struct msi_primary_key_record_info info; LibmsiQuery *query = NULL; unsigned r; @@ -2600,25 +2452,16 @@ unsigned _libmsi_database_get_primary_keys( LibmsiDatabase *db, LibmsiResult libmsi_database_get_primary_keys(LibmsiDatabase *db, const char *table, LibmsiRecord **prec) { - WCHAR *szwTable = NULL; unsigned r; TRACE("%d %s %p\n", db, debugstr_a(table), prec); - if( table ) - { - szwTable = strdupAtoW( table ); - if( !szwTable ) - return LIBMSI_RESULT_OUTOFMEMORY; - } - if( !db ) return LIBMSI_RESULT_INVALID_HANDLE; g_object_ref(db); - r = _libmsi_database_get_primary_keys( db, szwTable, prec ); + r = _libmsi_database_get_primary_keys( db, table, prec ); g_object_unref(db); - msi_free( szwTable ); return r; } @@ -2626,26 +2469,17 @@ LibmsiResult libmsi_database_get_primary_keys(LibmsiDatabase *db, LibmsiCondition libmsi_database_is_table_persistent( LibmsiDatabase *db, const char *szTableName) { - WCHAR *szwTableName = NULL; LibmsiCondition r; TRACE("%x %s\n", db, debugstr_a(szTableName)); - if( szTableName ) - { - szwTableName = strdupAtoW( szTableName ); - if( !szwTableName ) - return LIBMSI_CONDITION_ERROR; - } - g_object_ref(db); if( !db ) return LIBMSI_CONDITION_ERROR; - r = _libmsi_database_is_table_persistent( db, szwTableName ); + r = _libmsi_database_is_table_persistent( db, szTableName ); g_object_unref(db); - msi_free( szwTableName ); return r; } diff --git a/libmsi/libmsi-query.c b/libmsi/libmsi-query.c index 34512d9..d0c8a3b 100644 --- a/libmsi/libmsi-query.c +++ b/libmsi/libmsi-query.c @@ -20,22 +20,11 @@ #include <stdarg.h> -#define COBJMACROS - -#include "windef.h" -#include "winbase.h" -#include "winerror.h" - #include "libmsi-query.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" - #include "query.h" enum @@ -148,20 +137,17 @@ static gboolean init (LibmsiQuery *self, GError **error) { LibmsiQuery *p = self; - WCHAR *szwQuery; unsigned r; - szwQuery = strdupAtoW(p->query); - r = _libmsi_parse_sql (p->database, szwQuery, &p->view, &p->mem); - msi_free(szwQuery); + r = _libmsi_parse_sql (p->database, p->query, &p->view, &p->mem); return r == LIBMSI_RESULT_SUCCESS; } -unsigned _libmsi_view_find_column( LibmsiView *table, const WCHAR *name, const WCHAR *table_name, unsigned *n ) +unsigned _libmsi_view_find_column( LibmsiView *table, const char *name, const char *table_name, unsigned *n ) { - const WCHAR *col_name; - const WCHAR *haystack_table_name; + const char *col_name; + const char *haystack_table_name; unsigned i, count, r; r = table->ops->get_dimensions( table, NULL, &count ); @@ -176,9 +162,9 @@ unsigned _libmsi_view_find_column( LibmsiView *table, const WCHAR *name, const W NULL, &haystack_table_name ); if( r != LIBMSI_RESULT_SUCCESS ) return r; - x = strcmpW( name, col_name ); + x = strcmp( name, col_name ); if( table_name ) - x |= strcmpW( table_name, haystack_table_name ); + x |= strcmp( table_name, haystack_table_name ); if( !x ) { *n = i; @@ -192,56 +178,42 @@ LibmsiResult libmsi_database_open_query(LibmsiDatabase *db, const char *szQuery, LibmsiQuery **pQuery) { unsigned r; - WCHAR *szwQuery; TRACE("%d %s %p\n", db, debugstr_a(szQuery), pQuery); - if( szQuery ) - { - szwQuery = strdupAtoW( szQuery ); - if( !szwQuery ) - return LIBMSI_RESULT_FUNCTION_FAILED; - } - else - szwQuery = NULL; - if( !db ) return LIBMSI_RESULT_INVALID_HANDLE; g_object_ref(db); - r = _libmsi_database_open_query( db, szwQuery, pQuery ); + r = _libmsi_database_open_query( db, szQuery, pQuery ); g_object_unref(db); - msi_free( szwQuery ); return r; } unsigned _libmsi_database_open_query(LibmsiDatabase *db, - const WCHAR *szwQuery, LibmsiQuery **pView) + const char *szQuery, LibmsiQuery **pView) { - char *szQuery; - TRACE("%s %p\n", debugstr_w(szQuery), pView); + TRACE("%s %p\n", debugstr_a(szQuery), pView); - szQuery = strdupWtoA(szwQuery); *pView = libmsi_query_new (db, szQuery, NULL); - msi_free(szQuery); return *pView ? LIBMSI_RESULT_SUCCESS : LIBMSI_RESULT_BAD_QUERY_SYNTAX; } -unsigned _libmsi_query_open( LibmsiDatabase *db, LibmsiQuery **view, const WCHAR *fmt, ... ) +unsigned _libmsi_query_open( LibmsiDatabase *db, LibmsiQuery **view, const char *fmt, ... ) { unsigned r; int size = 100, res; - WCHAR *query; + char *query; /* construct the string */ for (;;) { va_list va; - query = msi_alloc( size*sizeof(WCHAR) ); + query = msi_alloc( size*sizeof(char) ); va_start(va, fmt); - res = vsnprintfW(query, size, fmt, va); + res = vsnprintf(query, size, fmt, va); va_end(va); if (res == -1) size *= 2; else if (res >= size) size = res + 1; @@ -292,21 +264,21 @@ unsigned _libmsi_query_iterate_records( LibmsiQuery *view, unsigned *count, } /* return a single record from a query */ -LibmsiRecord *_libmsi_query_get_record( LibmsiDatabase *db, const WCHAR *fmt, ... ) +LibmsiRecord *_libmsi_query_get_record( LibmsiDatabase *db, const char *fmt, ... ) { LibmsiRecord *rec = NULL; LibmsiQuery *view = NULL; unsigned r; int size = 100, res; - WCHAR *query; + char *query; /* construct the string */ for (;;) { va_list va; - query = msi_alloc( size*sizeof(WCHAR) ); + query = msi_alloc( size*sizeof(char) ); va_start(va, fmt); - res = vsnprintfW(query, size, fmt, va); + res = vsnprintf(query, size, fmt, va); va_end(va); if (res == -1) size *= 2; else if (res >= size) size = res + 1; @@ -358,13 +330,13 @@ unsigned msi_view_get_row(LibmsiDatabase *db, LibmsiView *view, unsigned row, Li if (MSITYPE_IS_BINARY(type)) { - IStream *stm = NULL; + GsfInput *stm = NULL; ret = view->ops->fetch_stream(view, row, i, &stm); if ((ret == LIBMSI_RESULT_SUCCESS) && stm) { - _libmsi_record_set_IStream(*rec, i, stm); - IStream_Release(stm); + _libmsi_record_set_gsf_input(*rec, i, stm); + g_object_unref(G_OBJECT(stm)); } else WARN("failed to get stream\n"); @@ -388,10 +360,10 @@ unsigned msi_view_get_row(LibmsiDatabase *db, LibmsiView *view, unsigned row, Li if (type & MSITYPE_STRING) { - const WCHAR *sval; + const char *sval; sval = msi_string_lookup_id(db->strings, ival); - _libmsi_record_set_stringW(*rec, i, sval); + libmsi_record_set_string(*rec, i, sval); } else { @@ -504,8 +476,8 @@ LibmsiResult libmsi_query_execute(LibmsiQuery *query, LibmsiRecord *rec) static unsigned msi_set_record_type_string( LibmsiRecord *rec, unsigned field, unsigned type, bool temporary ) { - static const WCHAR fmt[] = { '%','d',0 }; - WCHAR szType[0x10]; + static const char fmt[] = "%d"; + char szType[0x10]; if (MSITYPE_IS_BINARY(type)) szType[0] = 'v'; @@ -531,11 +503,11 @@ static unsigned msi_set_record_type_string( LibmsiRecord *rec, unsigned field, if (type & MSITYPE_NULLABLE) szType[0] &= ~0x20; - sprintfW( &szType[1], fmt, (type&0xff) ); + sprintf( &szType[1], fmt, (type&0xff) ); - TRACE("type %04x -> %s\n", type, debugstr_w(szType) ); + TRACE("type %04x -> %s\n", type, debugstr_a(szType) ); - return _libmsi_record_set_stringW( rec, field, szType ); + return libmsi_record_set_string( rec, field, szType ); } unsigned _libmsi_query_get_column_info( LibmsiQuery *query, LibmsiColInfo info, LibmsiRecord **prec ) @@ -543,7 +515,7 @@ unsigned _libmsi_query_get_column_info( LibmsiQuery *query, LibmsiColInfo info, unsigned r = LIBMSI_RESULT_FUNCTION_FAILED, i, count = 0, type; LibmsiRecord *rec; LibmsiView *view = query->view; - const WCHAR *name; + const char *name; bool temporary; if( !view ) @@ -569,7 +541,7 @@ unsigned _libmsi_query_get_column_info( LibmsiQuery *query, LibmsiColInfo info, if( r != LIBMSI_RESULT_SUCCESS ) continue; if (info == LIBMSI_COL_INFO_NAMES) - _libmsi_record_set_stringW( rec, i+1, name ); + libmsi_record_set_string( rec, i+1, name ); else msi_set_record_type_string( rec, i+1, type, temporary ); } @@ -601,7 +573,7 @@ LibmsiResult libmsi_query_get_column_info(LibmsiQuery *query, LibmsiColInfo info LibmsiDBError libmsi_query_get_error( LibmsiQuery *query, char *buffer, unsigned *buflen ) { - const WCHAR *column; + const char *column; LibmsiDBError r; unsigned len; @@ -617,11 +589,11 @@ LibmsiDBError libmsi_query_get_error( LibmsiQuery *query, char *buffer, unsigned if ((r = query->view->error)) column = query->view->error_column; else column = szEmpty; - len = WideCharToMultiByte( CP_ACP, 0, column, -1, NULL, 0, NULL, NULL ); + len = strlen(column); if (buffer) { if (*buflen >= len) - WideCharToMultiByte( CP_ACP, 0, column, -1, buffer, *buflen, NULL, NULL ); + strcpy(buffer, column); else r = LIBMSI_DB_ERROR_MOREDATA; } diff --git a/libmsi/libmsi-record.c b/libmsi/libmsi-record.c index 78b0e21..848ba61 100644 --- a/libmsi/libmsi-record.c +++ b/libmsi/libmsi-record.c @@ -20,24 +20,11 @@ #include <stdarg.h> -#define COBJMACROS - -#include "windef.h" -#include "winbase.h" -#include "winerror.h" - #include "libmsi-record.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" #include "msipriv.h" -#include "objidl.h" -#include "winnls.h" -#include "ole2.h" - -#include "shlwapi.h" - #include "query.h" enum @@ -51,7 +38,7 @@ G_DEFINE_TYPE (LibmsiRecord, libmsi_record, G_TYPE_OBJECT); #define LIBMSI_FIELD_TYPE_NULL 0 #define LIBMSI_FIELD_TYPE_INT 1 -#define LIBMSI_FIELD_TYPE_WSTR 3 +#define LIBMSI_FIELD_TYPE_STR 3 #define LIBMSI_FIELD_TYPE_STREAM 4 static void @@ -66,11 +53,11 @@ _libmsi_free_field (LibmsiField *field ) case LIBMSI_FIELD_TYPE_NULL: case LIBMSI_FIELD_TYPE_INT: break; - case LIBMSI_FIELD_TYPE_WSTR: - msi_free( field->u.szwVal); + case LIBMSI_FIELD_TYPE_STR: + msi_free (field->u.szVal); break; case LIBMSI_FIELD_TYPE_STREAM: - IStream_Release( field->u.stream ); + g_object_unref (G_OBJECT (field->u.stream)); break; default: ERR ("Invalid field type %d\n", field->type); @@ -159,10 +146,10 @@ unsigned libmsi_record_get_field_count( const LibmsiRecord *rec ) return rec->count; } -static bool expr_int_from_string( const WCHAR *str, int *out ) +static bool expr_int_from_string( const char *str, int *out ) { int x = 0; - const WCHAR *p = str; + const char *p = str; if( *p == '-' ) /* skip the minus sign */ p++; @@ -191,7 +178,7 @@ unsigned _libmsi_record_copy_field( LibmsiRecord *in_rec, unsigned in_n, r = LIBMSI_RESULT_FUNCTION_FAILED; else if ( in_rec != out_rec || in_n != out_n ) { - WCHAR *str; + char *str; LibmsiField *in, *out; in = &in_rec->fields[in_n]; @@ -204,15 +191,15 @@ unsigned _libmsi_record_copy_field( LibmsiRecord *in_rec, unsigned in_n, case LIBMSI_FIELD_TYPE_INT: out->u.iVal = in->u.iVal; break; - case LIBMSI_FIELD_TYPE_WSTR: - str = strdupW( in->u.szwVal ); + case LIBMSI_FIELD_TYPE_STR: + str = strdup( in->u.szVal ); if ( !str ) r = LIBMSI_RESULT_OUTOFMEMORY; else - out->u.szwVal = str; + out->u.szVal = str; break; case LIBMSI_FIELD_TYPE_STREAM: - IStream_AddRef( in->u.stream ); + g_object_ref(G_OBJECT(in->u.stream)); out->u.stream = in->u.stream; break; default: @@ -241,8 +228,8 @@ int libmsi_record_get_integer( const LibmsiRecord *rec, unsigned iField) { case LIBMSI_FIELD_TYPE_INT: return rec->fields[iField].u.iVal; - case LIBMSI_FIELD_TYPE_WSTR: - if( expr_int_from_string( rec->fields[iField].u.szwVal, &ret ) ) + case LIBMSI_FIELD_TYPE_STR: + if( expr_int_from_string( rec->fields[iField].u.szVal, &ret ) ) return ret; return MSI_NULL_INTEGER; default: @@ -329,21 +316,15 @@ LibmsiResult libmsi_record_get_string(const LibmsiRecord *rec, unsigned iField, switch( rec->fields[iField].type ) { case LIBMSI_FIELD_TYPE_INT: - wsprintfA(buffer, "%d", rec->fields[iField].u.iVal); + sprintf(buffer, "%d", rec->fields[iField].u.iVal); len = strlen( buffer ); if (szValue) - strcpynA(szValue, buffer, *pcchValue); + strcpyn(szValue, buffer, *pcchValue); break; - case LIBMSI_FIELD_TYPE_WSTR: - len = WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1, - NULL, 0 , NULL, NULL); + case LIBMSI_FIELD_TYPE_STR: + len = strlen( rec->fields[iField].u.szVal ); if (szValue) - WideCharToMultiByte( CP_ACP, 0, rec->fields[iField].u.szwVal, -1, - szValue, *pcchValue, NULL, NULL); - if( szValue && *pcchValue && len>*pcchValue ) - szValue[*pcchValue-1] = 0; - if( len ) - len--; + strcpyn(szValue, rec->fields[iField].u.szVal, *pcchValue ); break; case LIBMSI_FIELD_TYPE_NULL: if( szValue && *pcchValue > 0 ) @@ -361,23 +342,23 @@ LibmsiResult libmsi_record_get_string(const LibmsiRecord *rec, unsigned iField, return ret; } -const WCHAR *_libmsi_record_get_string_raw( const LibmsiRecord *rec, unsigned iField ) +const char *_libmsi_record_get_string_raw( const LibmsiRecord *rec, unsigned iField ) { if( iField > rec->count ) return NULL; - if( rec->fields[iField].type != LIBMSI_FIELD_TYPE_WSTR ) + if( rec->fields[iField].type != LIBMSI_FIELD_TYPE_STR ) return NULL; - return rec->fields[iField].u.szwVal; + return rec->fields[iField].u.szVal; } -unsigned _libmsi_record_get_stringW(const LibmsiRecord *rec, unsigned iField, - WCHAR *szValue, unsigned *pcchValue) +unsigned _libmsi_record_get_string(const LibmsiRecord *rec, unsigned iField, + char *szValue, unsigned *pcchValue) { unsigned len=0, ret; - WCHAR buffer[16]; - static const WCHAR szFormat[] = { '%','d',0 }; + char buffer[16]; + static const char szFormat[] = "%d"; TRACE("%p %d %p %p\n", rec, iField, szValue, pcchValue); @@ -394,15 +375,15 @@ unsigned _libmsi_record_get_stringW(const LibmsiRecord *rec, unsigned iField, switch( rec->fields[iField].type ) { case LIBMSI_FIELD_TYPE_INT: - wsprintfW(buffer, szFormat, rec->fields[iField].u.iVal); - len = strlenW( buffer ); + sprintf(buffer, szFormat, rec->fields[iField].u.iVal); + len = strlen( buffer ); if (szValue) - strcpynW(szValue, buffer, *pcchValue); + strcpyn(szValue, buffer, *pcchValue); break; - case LIBMSI_FIELD_TYPE_WSTR: - len = strlenW( rec->fields[iField].u.szwVal ); + case LIBMSI_FIELD_TYPE_STR: + len = strlen( rec->fields[iField].u.szVal ); if (szValue) - strcpynW(szValue, rec->fields[iField].u.szwVal, *pcchValue); + strcpyn(szValue, rec->fields[iField].u.szVal, *pcchValue); break; case LIBMSI_FIELD_TYPE_NULL: if( szValue && *pcchValue > 0 ) @@ -419,17 +400,6 @@ unsigned _libmsi_record_get_stringW(const LibmsiRecord *rec, unsigned iField, return ret; } -static unsigned msi_get_stream_size( IStream *stm ) -{ - STATSTG stat; - HRESULT r; - - r = IStream_Stat( stm, &stat, STATFLAG_NONAME ); - if( FAILED(r) ) - return 0; - return stat.cbSize.QuadPart; -} - unsigned libmsi_record_get_field_size(const LibmsiRecord *rec, unsigned iField) { TRACE("%p %d\n", rec, iField); @@ -444,35 +414,25 @@ unsigned libmsi_record_get_field_size(const LibmsiRecord *rec, unsigned iField) { case LIBMSI_FIELD_TYPE_INT: return sizeof (int); - case LIBMSI_FIELD_TYPE_WSTR: - return strlenW( rec->fields[iField].u.szwVal ); + case LIBMSI_FIELD_TYPE_STR: + return strlen( rec->fields[iField].u.szVal ); case LIBMSI_FIELD_TYPE_NULL: break; case LIBMSI_FIELD_TYPE_STREAM: - return msi_get_stream_size( rec->fields[iField].u.stream ); + return gsf_input_size( rec->fields[iField].u.stream ); } return 0; } LibmsiResult libmsi_record_set_string( LibmsiRecord *rec, unsigned iField, const char *szValue ) { - WCHAR *str; + char *str; TRACE("%d %d %s\n", rec, iField, debugstr_a(szValue)); if( !rec ) return LIBMSI_RESULT_INVALID_HANDLE; - str = strdupAtoW( szValue ); - return _libmsi_record_set_stringW( rec, iField, str ); -} - -unsigned _libmsi_record_set_stringW( LibmsiRecord *rec, unsigned iField, const WCHAR *szValue ) -{ - WCHAR *str; - - TRACE("%p %d %s\n", rec, iField, debugstr_w(szValue)); - if( iField > rec->count ) return LIBMSI_RESULT_INVALID_FIELD; @@ -480,70 +440,60 @@ unsigned _libmsi_record_set_stringW( LibmsiRecord *rec, unsigned iField, const W if( szValue && szValue[0] ) { - str = strdupW( szValue ); - rec->fields[iField].type = LIBMSI_FIELD_TYPE_WSTR; - rec->fields[iField].u.szwVal = str; + str = strdup( szValue ); + rec->fields[iField].type = LIBMSI_FIELD_TYPE_STR; + rec->fields[iField].u.szVal = str; } else { rec->fields[iField].type = LIBMSI_FIELD_TYPE_NULL; - rec->fields[iField].u.szwVal = NULL; + rec->fields[iField].u.szVal = NULL; } return 0; } -/* read the data in a file into an IStream */ -static unsigned _libmsi_addstream_from_file(const char *szFile, IStream **pstm) +/* read the data in a file into a memory-backed GsfInput */ +static unsigned _libmsi_addstream_from_file(const char *szFile, GsfInput **pstm) { - unsigned sz, szHighWord = 0, read; - HANDLE handle; - HGLOBAL hGlob = 0; - HRESULT hr; - ULARGE_INTEGER ulSize; + GsfInput *stm; + char *data; + off_t sz; - TRACE("reading %s\n", debugstr_a(szFile)); - - /* read the file into memory */ - handle = CreateFileA(szFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); - if( handle == INVALID_HANDLE_VALUE ) - return GetLastError(); - sz = GetFileSize(handle, &szHighWord); - if( sz != INVALID_FILE_SIZE && szHighWord == 0 ) + stm = gsf_input_stdio_new(szFile, NULL); + if (!stm) { - hGlob = GlobalAlloc(GMEM_FIXED, sz); - if( hGlob ) - { - bool r = ReadFile(handle, hGlob, sz, &read, NULL); - if( !r ) - { - GlobalFree(hGlob); - hGlob = 0; - } - } + WARN("open file failed for %s\n", debugstr_a(szFile)); + return LIBMSI_RESULT_OPEN_FAILED; } - CloseHandle(handle); - if( !hGlob ) - return LIBMSI_RESULT_FUNCTION_FAILED; - /* make a stream out of it, and set the correct file size */ - hr = CreateStreamOnHGlobal(hGlob, true, pstm); - if( FAILED( hr ) ) + sz = gsf_input_size(stm); + if (sz == 0) { - GlobalFree(hGlob); - return LIBMSI_RESULT_FUNCTION_FAILED; + data = g_malloc(1); } + else + { + data = g_try_malloc(sz); + if (!data) + return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - /* set the correct size - CreateStreamOnHGlobal screws it up */ - ulSize.QuadPart = sz; - IStream_SetSize(*pstm, ulSize); + if (!gsf_input_read(stm, sz, data)) + { + g_object_unref(G_OBJECT(stm)); + return LIBMSI_RESULT_FUNCTION_FAILED; + } + } + + g_object_unref(G_OBJECT(stm)); + *pstm = gsf_input_memory_new(data, sz, true); - TRACE("read %s, %d bytes into IStream %p\n", debugstr_a(szFile), sz, *pstm); + TRACE("read %s, %d bytes into GsfInput %p\n", debugstr_a(szFile), sz, *pstm); return LIBMSI_RESULT_SUCCESS; } -unsigned _libmsi_record_load_stream(LibmsiRecord *rec, unsigned iField, IStream *stream) +unsigned _libmsi_record_load_stream(LibmsiRecord *rec, unsigned iField, GsfInput *stream) { if ( (iField == 0) || (iField > rec->count) ) return LIBMSI_RESULT_INVALID_PARAMETER; @@ -557,8 +507,8 @@ unsigned _libmsi_record_load_stream(LibmsiRecord *rec, unsigned iField, IStream unsigned _libmsi_record_load_stream_from_file(LibmsiRecord *rec, unsigned iField, const char *szFilename) { - IStream *stm = NULL; - HRESULT r; + GsfInput *stm; + unsigned r; if( (iField == 0) || (iField > rec->count) ) return LIBMSI_RESULT_INVALID_PARAMETER; @@ -566,9 +516,6 @@ unsigned _libmsi_record_load_stream_from_file(LibmsiRecord *rec, unsigned iField /* no filename means we should seek back to the start of the stream */ if( !szFilename ) { - LARGE_INTEGER ofs; - ULARGE_INTEGER cur; - if( rec->fields[iField].type != LIBMSI_FIELD_TYPE_STREAM ) return LIBMSI_RESULT_INVALID_FIELD; @@ -576,10 +523,7 @@ unsigned _libmsi_record_load_stream_from_file(LibmsiRecord *rec, unsigned iField if( !stm ) return LIBMSI_RESULT_INVALID_FIELD; - ofs.QuadPart = 0; - r = IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur ); - if( FAILED( r ) ) - return LIBMSI_RESULT_FUNCTION_FAILED; + gsf_input_seek( stm, 0, G_SEEK_SET ); } else { @@ -613,9 +557,8 @@ LibmsiResult libmsi_record_load_stream(LibmsiRecord *rec, unsigned iField, const unsigned _libmsi_record_save_stream(const LibmsiRecord *rec, unsigned iField, char *buf, unsigned *sz) { - unsigned count; - HRESULT r; - IStream *stm; + uint64_t left; + GsfInput *stm; TRACE("%p %d %p %p\n", rec, iField, buf, sz); @@ -638,34 +581,26 @@ unsigned _libmsi_record_save_stream(const LibmsiRecord *rec, unsigned iField, ch if( !stm ) return LIBMSI_RESULT_INVALID_PARAMETER; + left = gsf_input_size(stm) - gsf_input_tell(stm); + /* if there's no buffer pointer, calculate the length to the end */ if( !buf ) { - LARGE_INTEGER ofs; - ULARGE_INTEGER end, cur; - - ofs.QuadPart = cur.QuadPart = 0; - end.QuadPart = 0; - IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur ); - IStream_Seek( stm, ofs, STREAM_SEEK_END, &end ); - ofs.QuadPart = cur.QuadPart; - IStream_Seek( stm, ofs, STREAM_SEEK_SET, &cur ); - *sz = end.QuadPart - cur.QuadPart; + *sz = left; return LIBMSI_RESULT_SUCCESS; } /* read the data */ - count = 0; - r = IStream_Read( stm, buf, *sz, &count ); - if( FAILED( r ) ) + if (*sz > left) + *sz = left; + + if (*sz > 0 && !gsf_input_read( stm, *sz, buf )) { *sz = 0; return LIBMSI_RESULT_FUNCTION_FAILED; } - *sz = count; - return LIBMSI_RESULT_SUCCESS; } @@ -685,7 +620,7 @@ LibmsiResult libmsi_record_save_stream(LibmsiRecord *rec, unsigned iField, char return ret; } -unsigned _libmsi_record_set_IStream( LibmsiRecord *rec, unsigned iField, IStream *stm ) +unsigned _libmsi_record_set_gsf_input( LibmsiRecord *rec, unsigned iField, GsfInput *stm ) { TRACE("%p %d %p\n", rec, iField, stm); @@ -696,12 +631,12 @@ unsigned _libmsi_record_set_IStream( LibmsiRecord *rec, unsigned iField, IStream rec->fields[iField].type = LIBMSI_FIELD_TYPE_STREAM; rec->fields[iField].u.stream = stm; - IStream_AddRef( stm ); + g_object_ref(G_OBJECT(stm)); return LIBMSI_RESULT_SUCCESS; } -unsigned _libmsi_record_get_IStream( const LibmsiRecord *rec, unsigned iField, IStream **pstm) +unsigned _libmsi_record_get_gsf_input( const LibmsiRecord *rec, unsigned iField, GsfInput **pstm) { TRACE("%p %d %p\n", rec, iField, pstm); @@ -712,7 +647,7 @@ unsigned _libmsi_record_get_IStream( const LibmsiRecord *rec, unsigned iField, I return LIBMSI_RESULT_INVALID_FIELD; *pstm = rec->fields[iField].u.stream; - IStream_AddRef( *pstm ); + g_object_ref(G_OBJECT(*pstm)); return LIBMSI_RESULT_SUCCESS; } @@ -731,12 +666,13 @@ LibmsiRecord *_libmsi_record_clone(LibmsiRecord *rec) { if (rec->fields[i].type == LIBMSI_FIELD_TYPE_STREAM) { - if (FAILED(IStream_Clone(rec->fields[i].u.stream, - &clone->fields[i].u.stream))) + GsfInput *stm = gsf_input_dup(rec->fields[i].u.stream, NULL); + if (!stm) { g_object_unref(clone); return NULL; } + clone->fields[i].u.stream = stm; clone->fields[i].type = LIBMSI_FIELD_TYPE_STREAM; } else @@ -768,8 +704,8 @@ bool _libmsi_record_compare_fields(const LibmsiRecord *a, const LibmsiRecord *b, return false; break; - case LIBMSI_FIELD_TYPE_WSTR: - if (strcmpW(a->fields[field].u.szwVal, b->fields[field].u.szwVal)) + case LIBMSI_FIELD_TYPE_STR: + if (strcmp(a->fields[field].u.szVal, b->fields[field].u.szVal)) return false; break; @@ -797,23 +733,23 @@ bool _libmsi_record_compare(const LibmsiRecord *a, const LibmsiRecord *b) return true; } -WCHAR *msi_dup_record_field( LibmsiRecord *rec, int field ) +char *msi_dup_record_field( LibmsiRecord *rec, int field ) { unsigned sz = 0; - WCHAR *str; + char *str; unsigned r; if (libmsi_record_is_null( rec, field )) return NULL; - r = _libmsi_record_get_stringW( rec, field, NULL, &sz ); + r = _libmsi_record_get_string( rec, field, NULL, &sz ); if (r != LIBMSI_RESULT_SUCCESS) return NULL; sz++; - str = msi_alloc( sz * sizeof(WCHAR) ); + str = msi_alloc( sz * sizeof(char) ); if (!str) return NULL; str[0] = 0; - r = _libmsi_record_get_stringW( rec, field, str, &sz ); + r = _libmsi_record_get_string( rec, field, str, &sz ); if (r != LIBMSI_RESULT_SUCCESS) { ERR("failed to get string!\n"); diff --git a/libmsi/libmsi-summary-info.c b/libmsi/libmsi-summary-info.c index 6e237dd..f34e04e 100644 --- a/libmsi/libmsi-summary-info.c +++ b/libmsi/libmsi-summary-info.c @@ -24,11 +24,7 @@ #include "libmsi-summary-info.h" -#define COBJMACROS -#define NONAMELESSUNION - #include "debug.h" -#include "unicode.h" #include "libmsi.h" #include "msipriv.h" @@ -43,11 +39,11 @@ enum G_DEFINE_TYPE (LibmsiSummaryInfo, libmsi_summary_info, G_TYPE_OBJECT); -static const WCHAR szSumInfo[] = {5 ,'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',0}; +static const char szSumInfo[] = "\5SummaryInformation"; static const uint8_t fmtid_SummaryInformation[16] = { 0xe0, 0x85, 0x9f, 0xf2, 0xf9, 0x4f, 0x68, 0x10, 0xab, 0x91, 0x08, 0x00, 0x2b, 0x27, 0xb3, 0xd9}; -static unsigned load_summary_info (LibmsiSummaryInfo *si, IStream *stm); +static unsigned load_summary_info( LibmsiSummaryInfo *si, GsfInput *stm ); static void libmsi_summary_info_init (LibmsiSummaryInfo *p) @@ -121,14 +117,14 @@ libmsi_summary_info_constructed (GObject *object) { LibmsiSummaryInfo *self = LIBMSI_SUMMARY_INFO (object); LibmsiSummaryInfo *p = self; - IStream *stm = NULL; + GsfInput *stm = NULL; unsigned r; /* read the stream... if we fail, we'll start with an empty property set */ r = msi_get_raw_stream (p->database, szSumInfo, &stm); if (r == 0) { load_summary_info (self, stm); - IStream_Release( stm ); + g_object_unref (G_OBJECT (stm)); } G_OBJECT_CLASS (libmsi_summary_info_parent_class)->constructed (object); @@ -199,7 +195,7 @@ static unsigned get_property_count( const LibmsiOLEVariant *property ) return n; } -static unsigned read_word( uint8_t *data, unsigned *ofs ) +static unsigned read_word( const uint8_t *data, unsigned *ofs ) { unsigned val = 0; val = data[*ofs]; @@ -208,7 +204,7 @@ static unsigned read_word( uint8_t *data, unsigned *ofs ) return val; } -static unsigned read_dword( uint8_t *data, unsigned *ofs ) +static unsigned read_dword( const uint8_t *data, unsigned *ofs ) { unsigned val = 0; val = data[*ofs]; @@ -219,41 +215,41 @@ static unsigned read_dword( uint8_t *data, unsigned *ofs ) return val; } -static void parse_filetime( const WCHAR *str, guint64 *ft ) +static void parse_filetime( const char *str, guint64 *ft ) { struct tm tm; time_t t; - const WCHAR *p = str; - WCHAR *end; + const char *p = str; + char *end; /* YYYY/MM/DD hh:mm:ss */ while ( *p == ' ' || *p == '\t' ) p++; - tm.tm_year = strtolW( p, &end, 10 ); + tm.tm_year = strtol( p, &end, 10 ); if (*end != '/') return; p = end + 1; - tm.tm_mon = strtolW( p, &end, 10 ) - 1; + tm.tm_mon = strtol( p, &end, 10 ) - 1; if (*end != '/') return; p = end + 1; - tm.tm_mday = strtolW( p, &end, 10 ); + tm.tm_mday = strtol( p, &end, 10 ); if (*end != ' ') return; p = end + 1; while ( *p == ' ' || *p == '\t' ) p++; - tm.tm_hour = strtolW( p, &end, 10 ); + tm.tm_hour = strtol( p, &end, 10 ); if (*end != ':') return; p = end + 1; - tm.tm_min = strtolW( p, &end, 10 ); + tm.tm_min = strtol( p, &end, 10 ); if (*end != ':') return; p = end + 1; - tm.tm_sec = strtolW( p, &end, 10 ); + tm.tm_sec = strtol( p, &end, 10 ); t = mktime(&tm); @@ -264,7 +260,7 @@ static void parse_filetime( const WCHAR *str, guint64 *ft ) } /* FIXME: doesn't deal with endian conversion */ -static void read_properties_from_data( LibmsiOLEVariant *prop, uint8_t *data, unsigned sz, uint32_t cProperties ) +static void read_properties_from_data( LibmsiOLEVariant *prop, const uint8_t *data, unsigned sz, uint32_t cProperties ) { unsigned type; unsigned i; @@ -347,9 +343,7 @@ static void read_properties_from_data( LibmsiOLEVariant *prop, uint8_t *data, un if( type == OLEVT_I2 || type == OLEVT_I4) { property->intval = atoi( str ); } else if( type == OLEVT_FILETIME) { - WCHAR *wstr = strdupAtoW(str); - parse_filetime( wstr, &property->filetime ); - msi_free (wstr); + parse_filetime( str, &property->filetime ); } msi_free (str); } @@ -361,40 +355,32 @@ static void read_properties_from_data( LibmsiOLEVariant *prop, uint8_t *data, un } } -static unsigned load_summary_info( LibmsiSummaryInfo *si, IStream *stm ) +static unsigned load_summary_info( LibmsiSummaryInfo *si, GsfInput *stm ) { unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; uint8_t *data = NULL; unsigned ofs, dwOffset; - unsigned count, size, cbSection, cProperties; - HRESULT r; - STATSTG stat; + unsigned cbSection, cProperties; + off_t sz; TRACE("%p %p\n", si, stm); - r = IStream_Stat(stm, &stat, STATFLAG_NONAME); - if (FAILED(r)) - return r; - - if (stat.cbSize.QuadPart >> 32) - { - ERR("Storage is too large\n"); + sz = gsf_input_size(stm); + if (!sz) return ret; - } - - size = stat.cbSize.QuadPart; - data = msi_alloc(size); + data = g_try_malloc(gsf_input_size(stm)); + if (!data) + return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - ofs = 0; - r = IStream_Read( stm, data, size, &count ); - if( FAILED(r) || count != size ) - return ret; + if (!gsf_input_read(stm, sz, data)) + goto done; /* process the set header */ + ofs = 0; if( read_word( data, &ofs) != 0xfffe ) { ERR("property set not little-endian\n"); - return ret; + goto done; } /* process the format header */ @@ -402,7 +388,7 @@ static unsigned load_summary_info( LibmsiSummaryInfo *si, IStream *stm ) /* check the format id is correct */ ofs = 28; if( memcmp( &fmtid_SummaryInformation, &data[ofs], 16 ) ) - return ret; + goto done; /* seek to the location of the section */ ofs += 16; @@ -415,7 +401,7 @@ static unsigned load_summary_info( LibmsiSummaryInfo *si, IStream *stm ) if( cProperties > MSI_MAX_PROPS ) { ERR("too many properties %d\n", cProperties); - return ret; + goto done; } /* read all the data in one go */ @@ -423,6 +409,7 @@ static unsigned load_summary_info( LibmsiSummaryInfo *si, IStream *stm ) &data[dwOffset], cbSection, cProperties ); +done: msi_free( data ); return ret; } @@ -494,7 +481,7 @@ static unsigned write_property_to_data( const LibmsiOLEVariant *prop, uint8_t *d static unsigned suminfo_persist( LibmsiSummaryInfo *si ) { int cProperties, cbSection, dwOffset; - IStream *stm; + GsfInput *stm; uint8_t *data = NULL; unsigned r, sz; int i; @@ -548,7 +535,7 @@ static unsigned suminfo_persist( LibmsiSummaryInfo *si ) r = write_raw_stream_data(si->database, szSumInfo, data, sz, &stm); if (r == 0) { - IStream_Release( stm ); + g_object_unref(G_OBJECT(stm)); } msi_free( data ); return r; @@ -556,7 +543,9 @@ static unsigned suminfo_persist( LibmsiSummaryInfo *si ) LibmsiSummaryInfo *_libmsi_get_summary_information( LibmsiDatabase *db, unsigned uiUpdateCount ) { + GsfInput *stm = NULL; LibmsiSummaryInfo *si; + unsigned r; TRACE("%p %d\n", db, uiUpdateCount ); @@ -648,7 +637,7 @@ LibmsiResult libmsi_summary_info_get_property( len = strlen( prop->strval ); if( szValueBuf ) - strcpynA(szValueBuf, prop->strval, *pcchValueBuf ); + strcpyn(szValueBuf, prop->strval, *pcchValueBuf ); if (len >= *pcchValueBuf) ret = LIBMSI_RESULT_MORE_DATA; *pcchValueBuf = len; @@ -765,10 +754,10 @@ LibmsiResult libmsi_summary_info_set_property( LibmsiSummaryInfo *si, unsigned u return _libmsi_summary_info_set_property( si, uiProperty, type, intvalue, pftValue, szValue ); } -static unsigned parse_prop( const WCHAR *prop, const WCHAR *value, unsigned *pid, int *int_value, +static unsigned parse_prop( const char *prop, const char *value, unsigned *pid, int *int_value, guint64 *ft_value, char **str_value ) { - *pid = atoiW( prop ); + *pid = atoi( prop ); switch (*pid) { case LIBMSI_PROPERTY_CODEPAGE: @@ -776,7 +765,7 @@ static unsigned parse_prop( const WCHAR *prop, const WCHAR *value, unsigned *pid case LIBMSI_PROPERTY_RESTRICT: case LIBMSI_PROPERTY_SECURITY: case LIBMSI_PROPERTY_VERSION: - *int_value = atoiW( value ); + *int_value = atoi( value ); break; case LIBMSI_PROPERTY_LASTPRINTED: @@ -794,7 +783,7 @@ static unsigned parse_prop( const WCHAR *prop, const WCHAR *value, unsigned *pid case LIBMSI_PROPERTY_UUID: case LIBMSI_PROPERTY_APPNAME: case LIBMSI_PROPERTY_TITLE: - *str_value = strdupWtoA(value); + *str_value = strdup(value); break; default: @@ -805,7 +794,7 @@ static unsigned parse_prop( const WCHAR *prop, const WCHAR *value, unsigned *pid return LIBMSI_RESULT_SUCCESS; } -unsigned msi_add_suminfo( LibmsiDatabase *db, WCHAR ***records, int num_records, int num_columns ) +unsigned msi_add_suminfo( LibmsiDatabase *db, char ***records, int num_records, int num_columns ) { unsigned r = LIBMSI_RESULT_FUNCTION_FAILED; unsigned i, j; diff --git a/libmsi/msipriv.h b/libmsi/msipriv.h index b085e27..a298ae3 100644 --- a/libmsi/msipriv.h +++ b/libmsi/msipriv.h @@ -23,22 +23,33 @@ #define __WINE_MSI_PRIVATE__ #include <stdarg.h> +#include <string.h> +#include <stdlib.h> #include <stdint.h> #include <stdbool.h> #include <glib.h> + #include <gsf/gsf.h> +#include <gsf/gsf-input.h> +#include <gsf/gsf-infile.h> +#include <gsf/gsf-output.h> +#include <gsf/gsf-outfile.h> +#include <gsf/gsf-input-memory.h> +#include <gsf/gsf-input-stdio.h> +#include <gsf/gsf-output-stdio.h> +#include <gsf/gsf-infile-msole.h> +#include <gsf/gsf-outfile-msole.h> + -#include "unicode.h" -#include "windef.h" -#include "winbase.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" -#include "winnls.h" #include "list.h" #pragma GCC visibility push(hidden) +#ifndef MAX_PATH +#define MAX_PATH PATH_MAX +#endif + #define MSI_DATASIZEMASK 0x00ff #define MSITYPE_VALID 0x0100 #define MSITYPE_LOCALIZABLE 0x200 @@ -66,8 +77,8 @@ struct _LibmsiDatabase { GObject parent; - IStorage *infile; - IStorage *outfile; + GsfInfile *infile; + GsfOutfile *outfile; string_table *strings; unsigned bytes_per_strref; char *path; @@ -103,8 +114,8 @@ typedef struct _LibmsiField union { int iVal; - WCHAR *szwVal; - IStream *stream; + char *szVal; + GsfInput *stream; } u; } LibmsiField; @@ -118,8 +129,8 @@ struct _LibmsiRecord typedef struct _column_info { - const WCHAR *table; - const WCHAR *column; + const char *table; + const char *column; int type; bool temporary; struct expr *val; @@ -147,7 +158,7 @@ typedef struct _LibmsiViewOps * This function is similar to fetch_int, except fetches a * stream instead of an integer. */ - unsigned (*fetch_stream)( LibmsiView *view, unsigned row, unsigned col, IStream **stm ); + unsigned (*fetch_stream)( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm ); /* * get_row - gets values from a row @@ -195,8 +206,8 @@ typedef struct _LibmsiViewOps * * The column information can be queried at any time. */ - unsigned (*get_column_info)( LibmsiView *view, unsigned n, const WCHAR **name, unsigned *type, - bool *temporary, const WCHAR **table_name ); + unsigned (*get_column_info)( LibmsiView *view, unsigned n, const char **name, unsigned *type, + bool *temporary, const char **table_name ); /* * delete - destroys the structure completely @@ -229,12 +240,12 @@ typedef struct _LibmsiViewOps /* * add_column - adds a column to the table */ - unsigned (*add_column)( LibmsiView *view, const WCHAR *table, unsigned number, const WCHAR *column, unsigned type, bool hold ); + unsigned (*add_column)( LibmsiView *view, const char *table, unsigned number, const char *column, unsigned type, bool hold ); /* * remove_column - removes the column represented by table name and column number from the table */ - unsigned (*remove_column)( LibmsiView *view, const WCHAR *table, unsigned number ); + unsigned (*remove_column)( LibmsiView *view, const char *table, unsigned number ); /* * sort - orders the table by columns @@ -251,7 +262,7 @@ struct _LibmsiView { const LibmsiViewOps *ops; LibmsiDBError error; - const WCHAR *error_column; + const char *error_column; }; #define MSI_MAX_PROPS 20 @@ -294,7 +305,7 @@ typedef struct { bool unicode; union { char *a; - WCHAR *w; + char *w; } str; } awstring; @@ -302,11 +313,11 @@ typedef struct { bool unicode; union { const char *a; - const WCHAR *w; + const char *w; } str; } awcstring; -unsigned msi_strcpy_to_awstring( const WCHAR *str, awstring *awbuf, unsigned *sz ); +unsigned msi_strcpy_to_awstring( const char *str, awstring *awbuf, unsigned *sz ); extern void free_cached_tables( LibmsiDatabase *db ); extern unsigned _libmsi_database_commit_tables( LibmsiDatabase *db, unsigned bytes_per_strref ); @@ -319,44 +330,43 @@ enum StringPersistence StringNonPersistent = 1 }; -extern int _libmsi_add_string( string_table *st, const WCHAR *data, int len, uint16_t refcount, enum StringPersistence persistence ); -extern unsigned _libmsi_id_from_stringW( const string_table *st, const WCHAR *buffer, unsigned *id ); -extern VOID msi_destroy_stringtable( string_table *st ); -extern const WCHAR *msi_string_lookup_id( const string_table *st, unsigned id ); +extern int _libmsi_add_string( string_table *st, const char *data, int len, uint16_t refcount, enum StringPersistence persistence ); +extern unsigned _libmsi_id_from_string_utf8( const string_table *st, const char *buffer, unsigned *id ); +extern void msi_destroy_stringtable( string_table *st ); +extern const char *msi_string_lookup_id( const string_table *st, unsigned id ); extern string_table *msi_init_string_table( unsigned *bytes_per_strref ); -extern string_table *msi_load_string_table( IStorage *stg, unsigned *bytes_per_strref ); +extern string_table *msi_load_string_table( GsfInfile *stg, unsigned *bytes_per_strref ); extern unsigned msi_save_string_table( const string_table *st, LibmsiDatabase *db, unsigned *bytes_per_strref ); extern unsigned msi_get_string_table_codepage( const string_table *st ); extern unsigned msi_set_string_table_codepage( string_table *st, unsigned codepage ); -unsigned _libmsi_open_table( LibmsiDatabase *db, const WCHAR *name, bool encoded ); -extern bool table_view_exists( LibmsiDatabase *db, const WCHAR *name ); -extern LibmsiCondition _libmsi_database_is_table_persistent( LibmsiDatabase *db, const WCHAR *table ); +unsigned _libmsi_open_table( LibmsiDatabase *db, const char *name, bool encoded ); +extern bool table_view_exists( LibmsiDatabase *db, const char *name ); +extern LibmsiCondition _libmsi_database_is_table_persistent( LibmsiDatabase *db, const char *table ); -extern unsigned read_stream_data( IStorage *stg, const WCHAR *stname, +extern unsigned read_stream_data( GsfInfile *stg, const char *stname, uint8_t **pdata, unsigned *psz ); -extern unsigned write_stream_data( LibmsiDatabase *db, const WCHAR *stname, +extern unsigned write_stream_data( LibmsiDatabase *db, const char *stname, const void *data, unsigned sz ); -extern unsigned write_raw_stream_data( LibmsiDatabase *db, const WCHAR *stname, - const void *data, unsigned sz, IStream **outstm ); +extern unsigned write_raw_stream_data( LibmsiDatabase *db, const char *stname, + const void *data, unsigned sz, GsfInput **outstm ); extern unsigned _libmsi_database_commit_streams( LibmsiDatabase *db ); /* transform functions */ -extern unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ); +extern unsigned msi_table_apply_transform( LibmsiDatabase *db, GsfInfile *stg ); extern unsigned _libmsi_database_apply_transform( LibmsiDatabase *db, const char *szTransformFile, int iErrorCond ); -extern void append_storage_to_db( LibmsiDatabase *db, IStorage *stg ); +extern void append_storage_to_db( LibmsiDatabase *db, GsfInfile *stg ); extern unsigned _libmsi_database_commit_storages( LibmsiDatabase *db ); /* record internals */ extern void _libmsi_record_destroy( LibmsiRecord * ); -extern unsigned _libmsi_record_set_IStream( LibmsiRecord *, unsigned, IStream *); -extern unsigned _libmsi_record_get_IStream( const LibmsiRecord *, unsigned, IStream **); -extern const WCHAR *_libmsi_record_get_string_raw( const LibmsiRecord *, unsigned ); -extern unsigned _libmsi_record_set_stringW( LibmsiRecord *, unsigned, const WCHAR *); -extern unsigned _libmsi_record_get_stringW( const LibmsiRecord *, unsigned, WCHAR *, unsigned *); +extern unsigned _libmsi_record_set_gsf_input( LibmsiRecord *, unsigned, GsfInput *); +extern unsigned _libmsi_record_get_gsf_input( const LibmsiRecord *, unsigned, GsfInput **); +extern const char *_libmsi_record_get_string_raw( const LibmsiRecord *, unsigned ); +extern unsigned _libmsi_record_get_string( const LibmsiRecord *, unsigned, char *, unsigned *); extern unsigned _libmsi_record_save_stream( const LibmsiRecord *, unsigned, char *, unsigned *); -extern unsigned _libmsi_record_load_stream(LibmsiRecord *, unsigned, IStream *); +extern unsigned _libmsi_record_load_stream(LibmsiRecord *, unsigned, GsfInput *); extern unsigned _libmsi_record_load_stream_from_file( LibmsiRecord *, unsigned, const char *); extern unsigned _libmsi_record_copy_field( LibmsiRecord *, unsigned, LibmsiRecord *, unsigned ); extern LibmsiRecord *_libmsi_record_clone( LibmsiRecord * ); @@ -364,55 +374,54 @@ extern bool _libmsi_record_compare( const LibmsiRecord *, const LibmsiRecord * ) extern bool _libmsi_record_compare_fields(const LibmsiRecord *a, const LibmsiRecord *b, unsigned field); /* stream internals */ -extern void enum_stream_names( IStorage *stg ); -extern WCHAR *encode_streamname(bool bTable, const WCHAR *in); -extern void decode_streamname(const WCHAR *in, WCHAR *out); +extern void enum_stream_names( GsfInfile *stg ); +extern char *encode_streamname(bool bTable, const char *in); +extern void decode_streamname(const char *in, char *out); /* database internals */ extern LibmsiResult _libmsi_database_start_transaction(LibmsiDatabase *db); extern LibmsiResult _libmsi_database_open(LibmsiDatabase *db); extern LibmsiResult _libmsi_database_close(LibmsiDatabase *db, bool committed); -unsigned msi_create_stream( LibmsiDatabase *db, const WCHAR *stname, IStream *stm ); -extern unsigned msi_get_raw_stream( LibmsiDatabase *, const WCHAR *, IStream **); -void msi_destroy_stream( LibmsiDatabase *, const WCHAR * ); -extern unsigned msi_enum_db_streams(LibmsiDatabase *, unsigned (*fn)(const WCHAR *, IStream *, void *), void *); -unsigned msi_create_storage( LibmsiDatabase *db, const WCHAR *stname, IStream *stm ); -unsigned msi_open_storage( LibmsiDatabase *db, const WCHAR *stname ); -void msi_destroy_storage( LibmsiDatabase *db, const WCHAR *stname ); -extern unsigned msi_enum_db_storages(LibmsiDatabase *, unsigned (*fn)(const WCHAR *, IStorage *, void *), void *); -extern unsigned _libmsi_database_open_query(LibmsiDatabase *, const WCHAR *, LibmsiQuery **); -extern unsigned _libmsi_query_open( LibmsiDatabase *, LibmsiQuery **, const WCHAR *, ... ); +unsigned msi_create_stream( LibmsiDatabase *db, const char *stname, GsfInput *stm ); +extern unsigned msi_get_raw_stream( LibmsiDatabase *, const char *, GsfInput **); +void msi_destroy_stream( LibmsiDatabase *, const char * ); +extern unsigned msi_enum_db_streams(LibmsiDatabase *, unsigned (*fn)(const char *, GsfInput *, void *), void *); +unsigned msi_create_storage( LibmsiDatabase *db, const char *stname, GsfInput *stm ); +unsigned msi_open_storage( LibmsiDatabase *db, const char *stname ); +void msi_destroy_storage( LibmsiDatabase *db, const char *stname ); +extern unsigned msi_enum_db_storages(LibmsiDatabase *, unsigned (*fn)(const char *, GsfInfile *, void *), void *); +extern unsigned _libmsi_database_open_query(LibmsiDatabase *, const char *, LibmsiQuery **); +extern unsigned _libmsi_query_open( LibmsiDatabase *, LibmsiQuery **, const char *, ... ); typedef unsigned (*record_func)( LibmsiRecord *, void *); extern unsigned _libmsi_query_iterate_records( LibmsiQuery *, unsigned *, record_func, void *); -extern LibmsiRecord *_libmsi_query_get_record( LibmsiDatabase *db, const WCHAR *query, ... ); -extern unsigned _libmsi_database_get_primary_keys( LibmsiDatabase *, const WCHAR *, LibmsiRecord **); +extern LibmsiRecord *_libmsi_query_get_record( LibmsiDatabase *db, const char *query, ... ); +extern unsigned _libmsi_database_get_primary_keys( LibmsiDatabase *, const char *, LibmsiRecord **); /* view internals */ extern unsigned _libmsi_query_execute( LibmsiQuery*, LibmsiRecord * ); extern unsigned _libmsi_query_fetch( LibmsiQuery*, LibmsiRecord ** ); extern unsigned _libmsi_query_get_column_info(LibmsiQuery *, LibmsiColInfo, LibmsiRecord **); -extern unsigned _libmsi_view_find_column( LibmsiView *, const WCHAR *, const WCHAR *, unsigned *); +extern unsigned _libmsi_view_find_column( LibmsiView *, const char *, const char *, unsigned *); extern unsigned msi_view_get_row(LibmsiDatabase *, LibmsiView *, unsigned, LibmsiRecord **); /* summary information */ -extern LibmsiSummaryInfo *MSI_GetSummaryInformationW( IStorage *stg, unsigned uiUpdateCount ); -extern unsigned msi_add_suminfo( LibmsiDatabase *db, WCHAR ***records, int num_records, int num_columns ); +extern unsigned msi_add_suminfo( LibmsiDatabase *db, char ***records, int num_records, int num_columns ); /* Helpers */ -extern WCHAR *msi_dup_record_field(LibmsiRecord *row, int index); -extern WCHAR *msi_dup_property( LibmsiDatabase *db, const WCHAR *prop ); -extern unsigned msi_set_property( LibmsiDatabase *, const WCHAR *, const WCHAR *); -extern unsigned msi_get_property( LibmsiDatabase *, const WCHAR *, WCHAR *, unsigned *); -extern int msi_get_property_int( LibmsiDatabase *package, const WCHAR *prop, int def ); +extern char *msi_dup_record_field(LibmsiRecord *row, int index); +extern char *msi_dup_property( LibmsiDatabase *db, const char *prop ); +extern unsigned msi_set_property( LibmsiDatabase *, const char *, const char *); +extern unsigned msi_get_property( LibmsiDatabase *, const char *, char *, unsigned *); +extern int msi_get_property_int( LibmsiDatabase *package, const char *prop, int def ); /* common strings */ -static const WCHAR szEmpty[] = {0}; -static const WCHAR szStreams[] = {'_','S','t','r','e','a','m','s',0}; -static const WCHAR szStorages[] = {'_','S','t','o','r','a','g','e','s',0}; -static const WCHAR szStringData[] = {'_','S','t','r','i','n','g','D','a','t','a',0}; -static const WCHAR szStringPool[] = {'_','S','t','r','i','n','g','P','o','o','l',0}; -static const WCHAR szName[] = {'N','a','m','e',0}; -static const WCHAR szData[] = {'D','a','t','a',0}; +static const char szEmpty[] = ""; +static const char szStreams[] = "_Streams"; +static const char szStorages[] = "_Storages"; +static const char szStringData[] = "_StringData"; +static const char szStringPool[] = "_StringPool"; +static const char szName[] = "Name"; +static const char szData[] = "Data"; /* memory allocation macro functions */ @@ -447,7 +456,7 @@ static inline void msi_free( void *mem ) free(mem); } -static inline char *strcpynA( char *dst, const char *src, unsigned count ) +static inline char *strcpyn( char *dst, const char *src, unsigned count ) { char *d = dst; const char *s = src; @@ -461,68 +470,6 @@ static inline char *strcpynA( char *dst, const char *src, unsigned count ) return dst; } -static inline char *strdupWtoUTF8( const WCHAR *str ) -{ - char *ret = NULL; - unsigned len; - - if (!str) return ret; - len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL); - ret = msi_alloc( len ); - if (ret) - WideCharToMultiByte( CP_UTF8, 0, str, -1, ret, len, NULL, NULL ); - return ret; -} - -static inline WCHAR *strdupUTF8toW( const char *str ) -{ - WCHAR *ret = NULL; - unsigned len; - - if (!str) return ret; - len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 ); - ret = msi_alloc( len * sizeof(WCHAR) ); - if (ret) - MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len ); - return ret; -} - -static inline char *strdupWtoA( const WCHAR *str ) -{ - char *ret = NULL; - unsigned len; - - if (!str) return ret; - len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL); - ret = msi_alloc( len ); - if (ret) - WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL ); - return ret; -} - -static inline WCHAR *strdupAtoW( const char *str ) -{ - WCHAR *ret = NULL; - unsigned len; - - if (!str) return ret; - len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 ); - ret = msi_alloc( len * sizeof(WCHAR) ); - if (ret) - MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len ); - return ret; -} - -static inline WCHAR *strdupW( const WCHAR *src ) -{ - WCHAR *dest; - if (!src) return NULL; - dest = msi_alloc( (strlenW(src)+1)*sizeof(WCHAR) ); - if (dest) - strcpyW(dest, src); - return dest; -} - #pragma GCC visibility pop #endif /* __WINE_MSI_PRIVATE__ */ diff --git a/libmsi/query.h b/libmsi/query.h index 48e4ebc..78791fd 100644 --- a/libmsi/query.h +++ b/libmsi/query.h @@ -18,17 +18,12 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#ifndef __WINE_MSI_QUERY_H -#define __WINE_MSI_QUERY_H +#ifndef __LIBMSI_QUERY_H +#define __LIBMSI_QUERY_H #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "objbase.h" -#include "objidl.h" -#include "msi.h" -#include "msiquery.h" +#include "libmsi.h" #include "msipriv.h" #include "list.h" @@ -58,7 +53,7 @@ #define EXPR_UNARY 12 struct sql_str { - const WCHAR *data; + const char *data; int len; }; @@ -74,8 +69,8 @@ union ext_column { struct { - const WCHAR *column; - const WCHAR *table; + const char *column; + const char *table; } unparsed; struct { @@ -92,15 +87,15 @@ struct expr struct complex_expr expr; int ival; unsigned uval; - const WCHAR *sval; + const char *sval; union ext_column column; } u; }; -unsigned _libmsi_parse_sql( LibmsiDatabase *db, const WCHAR *command, LibmsiView **phview, +unsigned _libmsi_parse_sql( LibmsiDatabase *db, const char *command, LibmsiView **phview, struct list *mem ); -unsigned table_view_create( LibmsiDatabase *db, const WCHAR *name, LibmsiView **view ); +unsigned table_view_create( LibmsiDatabase *db, const char *name, LibmsiView **view ); unsigned select_view_create( LibmsiDatabase *db, LibmsiView **view, LibmsiView *table, const column_info *columns ); @@ -110,35 +105,35 @@ unsigned distinct_view_create( LibmsiDatabase *db, LibmsiView **view, LibmsiView unsigned order_view_create( LibmsiDatabase *db, LibmsiView **view, LibmsiView *table, column_info *columns ); -unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *tables, +unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, char *tables, struct expr *cond ); -unsigned create_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *table, +unsigned create_view_create( LibmsiDatabase *db, LibmsiView **view, const char *table, column_info *col_info, bool hold ); -unsigned insert_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *table, +unsigned insert_view_create( LibmsiDatabase *db, LibmsiView **view, const char *table, column_info *columns, column_info *values, bool temp ); -unsigned update_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *table, +unsigned update_view_create( LibmsiDatabase *db, LibmsiView **view, char *table, column_info *list, struct expr *expr ); unsigned delete_view_create( LibmsiDatabase *db, LibmsiView **view, LibmsiView *table ); -unsigned alter_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *name, column_info *colinfo, int hold ); +unsigned alter_view_create( LibmsiDatabase *db, LibmsiView **view, const char *name, column_info *colinfo, int hold ); unsigned streams_view_create( LibmsiDatabase *db, LibmsiView **view ); unsigned storages_view_create( LibmsiDatabase *db, LibmsiView **view ); -unsigned drop_view_create( LibmsiDatabase *db, LibmsiView **view, const WCHAR *name ); +unsigned drop_view_create( LibmsiDatabase *db, LibmsiView **view, const char *name ); -int sql_get_token(const WCHAR *z, int *tokenType, int *skip); +int sql_get_token(const char *z, int *tokenType, int *skip); LibmsiRecord *msi_query_merge_record( unsigned fields, const column_info *vl, LibmsiRecord *rec ); -unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *col_info, +unsigned msi_create_table( LibmsiDatabase *db, const char *name, column_info *col_info, LibmsiCondition persistent ); #pragma GCC visibility pop -#endif /* __WINE_MSI_QUERY_H */ +#endif /* __LIBMSI_QUERY_H */ diff --git a/libmsi/select.c b/libmsi/select.c index d596d12..7fe5a16 100644 --- a/libmsi/select.c +++ b/libmsi/select.c @@ -20,15 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -67,7 +61,7 @@ static unsigned select_view_fetch_int( LibmsiView *view, unsigned row, unsigned return sv->table->ops->fetch_int( sv->table, row, col, val ); } -static unsigned select_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, IStream **stm) +static unsigned select_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm) { LibmsiSelectView *sv = (LibmsiSelectView*)view; @@ -214,8 +208,8 @@ static unsigned select_view_get_dimensions( LibmsiView *view, unsigned *rows, un return sv->table->ops->get_dimensions( sv->table, rows, NULL ); } -static unsigned select_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned select_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiSelectView *sv = (LibmsiSelectView*)view; @@ -296,14 +290,14 @@ static const LibmsiViewOps select_ops = NULL, }; -static unsigned select_view_add_column( LibmsiSelectView *sv, const WCHAR *name, - const WCHAR *table_name ) +static unsigned select_view_add_column( LibmsiSelectView *sv, const char *name, + const char *table_name ) { unsigned r, n; LibmsiView *table; - TRACE("%p adding %s.%s\n", sv, debugstr_w( table_name ), - debugstr_w( name )); + TRACE("%p adding %s.%s\n", sv, debugstr_a( table_name ), + debugstr_a( name )); if( sv->view.ops != &select_ops ) return LIBMSI_RESULT_FUNCTION_FAILED; @@ -329,7 +323,7 @@ static unsigned select_view_add_column( LibmsiSelectView *sv, const WCHAR *name, sv->cols[sv->num_cols] = n; TRACE("Translating column %s from %d -> %d\n", - debugstr_w( name ), sv->num_cols, n); + debugstr_a( name ), sv->num_cols, n); sv->num_cols++; diff --git a/libmsi/sql-parser.y b/libmsi/sql-parser.y index ddbbf97..4725fd8 100644 --- a/libmsi/sql-parser.y +++ b/libmsi/sql-parser.y @@ -27,12 +27,9 @@ #include <stdio.h> #include <stdlib.h> -#include "windef.h" -#include "winbase.h" #include "query.h" #include "list.h" #include "debug.h" -#include "unicode.h" #define YYLEX_PARAM info #define YYPARSE_PARAM info @@ -43,7 +40,7 @@ static int sql_error(void *info, const char *str); typedef struct _LibmsiSQLInput { LibmsiDatabase *db; - const WCHAR *command; + const char *command; unsigned n, len; unsigned r; LibmsiView **view; /* View structure for the resulting query. This value @@ -53,13 +50,13 @@ typedef struct _LibmsiSQLInput struct list *mem; } SQL_input; -static unsigned sql_unescape_string( void *info, const struct sql_str *strdata, WCHAR **str ); -static INT sql_atoi( void *info ); +static unsigned sql_unescape_string( void *info, const struct sql_str *strdata, char **str ); +static int sql_atoi( void *info ); static int sql_lex( void *SQL_lval, SQL_input *info ); -static WCHAR *parser_add_table( void *info, const WCHAR *list, const WCHAR *table ); +static char *parser_add_table( void *info, const char *list, const char *table ); static void *parser_alloc( void *info, unsigned int sz ); -static column_info *parser_alloc_column( void *info, const WCHAR *table, const WCHAR *column ); +static column_info *parser_alloc_column( void *info, const char *table, const char *column ); static bool sql_mark_primary_keys( column_info **cols, column_info *keys); @@ -83,7 +80,7 @@ static struct expr * build_expr_wildcard( void *info ); %union { struct sql_str str; - WCHAR *string; + char *string; column_info *column_list; LibmsiView *query; struct expr *expr; @@ -753,18 +750,18 @@ number: %% -static WCHAR *parser_add_table( void *info, const WCHAR *list, const WCHAR *table ) +static char *parser_add_table( void *info, const char *list, const char *table ) { - static const WCHAR space[] = {' ',0}; - unsigned len = strlenW( list ) + strlenW( table ) + 2; - WCHAR *ret; + static const char space[] = {' ',0}; + unsigned len = strlen( list ) + strlen( table ) + 2; + char *ret; - ret = parser_alloc( info, len * sizeof(WCHAR) ); + ret = parser_alloc( info, len * sizeof(char) ); if( ret ) { - strcpyW( ret, list ); - strcatW( ret, space ); - strcatW( ret, table ); + strcpy( ret, list ); + strcat( ret, space ); + strcat( ret, table ); } return ret; } @@ -779,7 +776,7 @@ static void *parser_alloc( void *info, unsigned int sz ) return &mem[1]; } -static column_info *parser_alloc_column( void *info, const WCHAR *table, const WCHAR *column ) +static column_info *parser_alloc_column( void *info, const char *table, const char *column ) { column_info *col; @@ -807,7 +804,7 @@ static int sql_lex( void *SQL_lval, SQL_input *sql ) if( ! sql->command[sql->n] ) return 0; /* end of input */ - /* TRACE("string : %s\n", debugstr_w(&sql->command[sql->n])); */ + /* TRACE("string : %s\n", debugstr_a(&sql->command[sql->n])); */ sql->len = sql_get_token( &sql->command[sql->n], &token, &skip ); if( sql->len==0 ) break; @@ -817,14 +814,14 @@ static int sql_lex( void *SQL_lval, SQL_input *sql ) } while( token == TK_SPACE ); - /* TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len)); */ + /* TRACE("token : %d (%s)\n", token, debugstr_an(&sql->command[sql->n], sql->len)); */ return token; } -unsigned sql_unescape_string( void *info, const struct sql_str *strdata, WCHAR **str ) +unsigned sql_unescape_string( void *info, const struct sql_str *strdata, char **str ) { - const WCHAR *p = strdata->data; + const char *p = strdata->data; unsigned len = strdata->len; /* match quotes */ @@ -839,20 +836,20 @@ unsigned sql_unescape_string( void *info, const struct sql_str *strdata, WCHAR * p++; len -= 2; } - *str = parser_alloc( info, (len + 1)*sizeof(WCHAR) ); + *str = parser_alloc( info, (len + 1)*sizeof(char) ); if( !*str ) return LIBMSI_RESULT_OUTOFMEMORY; - memcpy( *str, p, len*sizeof(WCHAR) ); + memcpy( *str, p, len*sizeof(char) ); (*str)[len]=0; return LIBMSI_RESULT_SUCCESS; } -INT sql_atoi( void *info ) +int sql_atoi( void *info ) { SQL_input* sql = (SQL_input*) info; - const WCHAR *p = &sql->command[sql->n]; - INT i, r = 0; + const char *p = &sql->command[sql->n]; + int i, r = 0; for( i=0; i<sql->len; i++ ) { @@ -937,7 +934,7 @@ static struct expr * build_expr_sval( void *info, const struct sql_str *str ) if( e ) { e->type = EXPR_SVAL; - if( sql_unescape_string( info, str, (WCHAR **)&e->u.sval ) != LIBMSI_RESULT_SUCCESS ) + if( sql_unescape_string( info, str, (char **)&e->u.sval ) != LIBMSI_RESULT_SUCCESS ) return NULL; /* e will be freed by query destructor */ } return e; @@ -987,7 +984,7 @@ static bool sql_mark_primary_keys( column_info **cols, found = false; for( c = *cols, idx = 0; c && !found; c = c->next, idx++ ) { - if( strcmpW( k->column, c->column ) ) + if( strcmp( k->column, c->column ) ) continue; c->type |= MSITYPE_KEY; found = true; @@ -999,7 +996,7 @@ static bool sql_mark_primary_keys( column_info **cols, return found; } -unsigned _libmsi_parse_sql( LibmsiDatabase *db, const WCHAR *command, LibmsiView **phview, +unsigned _libmsi_parse_sql( LibmsiDatabase *db, const char *command, LibmsiView **phview, struct list *mem ) { SQL_input sql; diff --git a/libmsi/storages.c b/libmsi/storages.c index f154c82..6829849 100644 --- a/libmsi/storages.c +++ b/libmsi/storages.c @@ -20,14 +20,7 @@ #include <stdarg.h> -#define COBJMACROS - -#include "windef.h" -#include "winbase.h" -#include "winerror.h" -#include "ole2.h" #include "libmsi.h" -#include "objbase.h" #include "msipriv.h" #include "query.h" @@ -65,7 +58,7 @@ static bool storages_set_table_size(LibmsiStorageView *sv, unsigned size) return true; } -static STORAGE *create_storage(LibmsiStorageView *sv, const WCHAR *name) +static STORAGE *create_storage(LibmsiStorageView *sv, const char *name) { STORAGE *storage; @@ -95,7 +88,7 @@ static unsigned storages_view_fetch_int(LibmsiView *view, unsigned row, unsigned return LIBMSI_RESULT_SUCCESS; } -static unsigned storages_view_fetch_stream(LibmsiView *view, unsigned row, unsigned col, IStream **stm) +static unsigned storages_view_fetch_stream(LibmsiView *view, unsigned row, unsigned col, GsfInput **stm) { LibmsiStorageView *sv = (LibmsiStorageView *)view; @@ -119,8 +112,9 @@ static unsigned storages_view_get_row( LibmsiView *view, unsigned row, LibmsiRec static unsigned storages_view_set_row(LibmsiView *view, unsigned row, LibmsiRecord *rec, unsigned mask) { LibmsiStorageView *sv = (LibmsiStorageView *)view; - IStream *stm; - WCHAR *name = NULL; + STORAGE *storage; + GsfInput *stm; + char *name = NULL; unsigned r = LIBMSI_RESULT_FUNCTION_FAILED; TRACE("(%p, %p)\n", view, rec); @@ -128,11 +122,21 @@ static unsigned storages_view_set_row(LibmsiView *view, unsigned row, LibmsiReco if (row > sv->num_rows) return LIBMSI_RESULT_FUNCTION_FAILED; - r = _libmsi_record_get_IStream(rec, 2, &stm); + r = _libmsi_record_get_gsf_input(rec, 2, &stm); if (r != LIBMSI_RESULT_SUCCESS) return r; - name = strdupW(_libmsi_record_get_string_raw(rec, 1)); + if (sv->storages[row]) { + if (mask & 1) { + FIXME("renaming storage via UPDATE on _Storages table\n"); + goto done; + } + + storage = sv->storages[row]; + name = strdup(msi_string_lookup_id(sv->db->strings, storage->str_index)); + } else { + name = strdup(_libmsi_record_get_string_raw(rec, 1)); + } if (!name) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -140,19 +144,15 @@ static unsigned storages_view_set_row(LibmsiView *view, unsigned row, LibmsiReco } msi_create_storage(sv->db, name, stm); - if (r != LIBMSI_RESULT_SUCCESS) - { - IStream_Release(stm); - return r; - } - - sv->storages[row] = create_storage(sv, name); - if (!sv->storages[row]) + storage = create_storage(sv, name); + if (!storage) r = LIBMSI_RESULT_FUNCTION_FAILED; + sv->storages[row] = storage; + done: msi_free(name); - IStream_Release(stm); + g_object_unref(G_OBJECT(stm)); return r; } @@ -175,8 +175,7 @@ static unsigned storages_view_insert_row(LibmsiView *view, LibmsiRecord *rec, un static unsigned storages_view_delete_row(LibmsiView *view, unsigned row) { LibmsiStorageView *sv = (LibmsiStorageView *)view; - const WCHAR *name; - WCHAR *encname; + const char *name; unsigned i; if (row > sv->num_rows) @@ -225,8 +224,8 @@ static unsigned storages_view_get_dimensions(LibmsiView *view, unsigned *rows, u return LIBMSI_RESULT_SUCCESS; } -static unsigned storages_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned storages_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary, table_name); @@ -272,7 +271,7 @@ static unsigned storages_view_find_matching_rows(LibmsiView *view, unsigned col, unsigned val, unsigned *row, MSIITERHANDLE *handle) { LibmsiStorageView *sv = (LibmsiStorageView *)view; - unsigned index = PtrToUlong(*handle); + unsigned index = (uintptr_t)*handle; TRACE("(%d, %d): %d\n", *row, col, val); @@ -290,7 +289,7 @@ static unsigned storages_view_find_matching_rows(LibmsiView *view, unsigned col, index++; } - *handle = UlongToPtr(++index); + *handle = (MSIITERHANDLE)(uintptr_t)++index; if (index >= sv->num_rows) return LIBMSI_RESULT_NO_MORE_ITEMS; @@ -319,7 +318,7 @@ static const LibmsiViewOps storages_ops = NULL, }; -static unsigned add_storage_to_table(const WCHAR *name, IStorage *stg, void *opaque) +static unsigned add_storage_to_table(const char *name, GsfInfile *stg, void *opaque) { LibmsiStorageView *sv = (LibmsiStorageView *)opaque; STORAGE *storage; diff --git a/libmsi/streams.c b/libmsi/streams.c index dbd8c17..93e05cc 100644 --- a/libmsi/streams.c +++ b/libmsi/streams.c @@ -20,18 +20,11 @@ #include <stdarg.h> -#define COBJMACROS - -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "libmsi.h" -#include "objbase.h" #include "msipriv.h" #include "query.h" #include "debug.h" -#include "unicode.h" #define NUM_STREAMS_COLS 2 @@ -39,7 +32,7 @@ typedef struct tabSTREAM { unsigned str_index; - IStream *stream; + GsfInput *stream; } STREAM; typedef struct _LibmsiStreamsView @@ -66,10 +59,10 @@ static bool streams_set_table_size(LibmsiStreamsView *sv, unsigned size) return true; } -static STREAM *create_stream(LibmsiStreamsView *sv, const WCHAR *name, bool encoded, IStream *stm) +static STREAM *create_stream(LibmsiStreamsView *sv, const char *name, bool encoded, GsfInput *stm) { STREAM *stream; - WCHAR decoded[MAX_STREAM_NAME_LEN]; + char decoded[MAX_STREAM_NAME_LEN]; stream = msi_alloc(sizeof(STREAM)); if (!stream) @@ -78,14 +71,14 @@ static STREAM *create_stream(LibmsiStreamsView *sv, const WCHAR *name, bool enco if (encoded) { decode_streamname(name, decoded); - TRACE("stream -> %s %s\n", debugstr_w(name), debugstr_w(decoded)); + TRACE("stream -> %s %s\n", debugstr_a(name), debugstr_a(decoded)); name = decoded; } stream->str_index = _libmsi_add_string(sv->db->strings, name, -1, 1, StringNonPersistent); stream->stream = stm; if (stream->stream) - IStream_AddRef(stm); + g_object_ref(G_OBJECT(stm)); return stream; } @@ -107,7 +100,7 @@ static unsigned streams_view_fetch_int(LibmsiView *view, unsigned row, unsigned return LIBMSI_RESULT_SUCCESS; } -static unsigned streams_view_fetch_stream(LibmsiView *view, unsigned row, unsigned col, IStream **stm) +static unsigned streams_view_fetch_stream(LibmsiView *view, unsigned row, unsigned col, GsfInput **stm) { LibmsiStreamsView *sv = (LibmsiStreamsView *)view; @@ -116,7 +109,7 @@ static unsigned streams_view_fetch_stream(LibmsiView *view, unsigned row, unsign if (row >= sv->num_rows) return LIBMSI_RESULT_FUNCTION_FAILED; - IStream_AddRef(sv->streams[row]->stream); + g_object_ref(G_OBJECT(sv->streams[row]->stream)); *stm = sv->streams[row]->stream; return LIBMSI_RESULT_SUCCESS; @@ -135,8 +128,8 @@ static unsigned streams_view_set_row(LibmsiView *view, unsigned row, LibmsiRecor { LibmsiStreamsView *sv = (LibmsiStreamsView *)view; STREAM *stream = NULL; - IStream *stm; - WCHAR *name = NULL; + GsfInput *stm; + char *name = NULL; unsigned r; TRACE("(%p, %d, %p, %08x)\n", view, row, rec, mask); @@ -144,18 +137,29 @@ static unsigned streams_view_set_row(LibmsiView *view, unsigned row, LibmsiRecor if (row > sv->num_rows) return LIBMSI_RESULT_FUNCTION_FAILED; - r = _libmsi_record_get_IStream(rec, 2, &stm); + r = _libmsi_record_get_gsf_input(rec, 2, &stm); if (r != LIBMSI_RESULT_SUCCESS) return r; - name = strdupW(_libmsi_record_get_string_raw(rec, 1)); - if (!name) - { - WARN("failed to retrieve stream name\n"); - goto done; + if (sv->streams[row]) { + if (mask & 1) { + FIXME("renaming stream via UPDATE on _Streams table"); + goto done; + } + + stream = sv->streams[row]; + name = strdup(msi_string_lookup_id(sv->db->strings, stream->str_index)); + } else { + name = strdup(_libmsi_record_get_string_raw(rec, 1)); + if (!name) + { + WARN("failed to retrieve stream name\n"); + goto done; + } + + stream = create_stream(sv, name, false, stm); } - stream = create_stream(sv, name, false, stm); if (!stream) goto done; @@ -163,7 +167,7 @@ static unsigned streams_view_set_row(LibmsiView *view, unsigned row, LibmsiRecor if (r != LIBMSI_RESULT_SUCCESS) { WARN("failed to create stream: %08x\n", r); - IStream_Release(stream->stream); + g_object_unref(G_OBJECT(stream->stream)); msi_free(stream); goto done; } @@ -173,7 +177,7 @@ static unsigned streams_view_set_row(LibmsiView *view, unsigned row, LibmsiRecor done: msi_free(name); - IStream_Release(stm); + g_object_unref(G_OBJECT(stm)); return r; } @@ -203,8 +207,8 @@ static unsigned streams_view_insert_row(LibmsiView *view, LibmsiRecord *rec, uns static unsigned streams_view_delete_row(LibmsiView *view, unsigned row) { LibmsiStreamsView *sv = (LibmsiStreamsView *)view; - const WCHAR *name; - WCHAR *encname; + const char *name; + char *encname; unsigned i; if (row > sv->num_rows) @@ -254,8 +258,8 @@ static unsigned streams_view_get_dimensions(LibmsiView *view, unsigned *rows, un return LIBMSI_RESULT_SUCCESS; } -static unsigned streams_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned streams_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary, table_name); @@ -292,7 +296,7 @@ static unsigned streams_view_delete(LibmsiView *view) if (sv->streams[i]) { if (sv->streams[i]->stream) - IStream_Release(sv->streams[i]->stream); + g_object_unref(G_OBJECT(sv->streams[i]->stream)); msi_free(sv->streams[i]); } } @@ -307,7 +311,7 @@ static unsigned streams_view_find_matching_rows(LibmsiView *view, unsigned col, unsigned val, unsigned *row, MSIITERHANDLE *handle) { LibmsiStreamsView *sv = (LibmsiStreamsView *)view; - unsigned index = PtrToUlong(*handle); + unsigned index = (uintptr_t)(*handle); TRACE("(%p, %d, %d, %p, %p)\n", view, col, val, row, handle); @@ -325,7 +329,7 @@ static unsigned streams_view_find_matching_rows(LibmsiView *view, unsigned col, index++; } - *handle = UlongToPtr(++index); + *handle = (MSIITERHANDLE)(uintptr_t)++index; if (index > sv->num_rows) return LIBMSI_RESULT_NO_MORE_ITEMS; @@ -355,7 +359,7 @@ static const LibmsiViewOps streams_ops = NULL, }; -static unsigned add_stream_to_table(const WCHAR *name, IStream *stm, void *opaque) +static unsigned add_stream_to_table(const char *name, GsfInput *stm, void *opaque) { LibmsiStreamsView *sv = (LibmsiStreamsView *)opaque; STREAM *stream; diff --git a/libmsi/string.c b/libmsi/string.c index a638197..2f3d144 100644 --- a/libmsi/string.c +++ b/libmsi/string.c @@ -20,30 +20,23 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ -#define COBJMACROS - #include <stdarg.h> #include <assert.h> +#include <gsf/gsf-msole-utils.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" +#define CP_ACP 0 struct msistring { uint16_t persistent_refcount; uint16_t nonpersistent_refcount; - WCHAR *str; + char *str; }; struct string_table @@ -59,7 +52,7 @@ struct string_table static bool validate_codepage( unsigned codepage ) { switch (codepage) { - case 0: /* CP_ACP */ + case CP_ACP: case 37: case 424: case 437: case 500: case 737: case 775: case 850: case 852: case 855: case 856: case 857: case 860: case 861: case 862: case 863: case 864: case 865: case 866: case 869: case 874: case 875: @@ -114,7 +107,7 @@ static string_table *init_stringtable( int entries, unsigned codepage ) return st; } -VOID msi_destroy_stringtable( string_table *st ) +void msi_destroy_stringtable( string_table *st ) { unsigned i; @@ -179,7 +172,7 @@ static int find_insert_index( const string_table *st, unsigned string_id ) while (low <= high) { i = (low + high) / 2; - c = strcmpW( st->strings[string_id].str, st->strings[st->sorted[i]].str ); + c = strcmp( st->strings[string_id].str, st->strings[st->sorted[i]].str ); if (c < 0) high = i - 1; @@ -204,7 +197,7 @@ static void insert_string_sorted( string_table *st, unsigned string_id ) st->sortcount++; } -static void set_st_entry( string_table *st, unsigned n, WCHAR *str, uint16_t refcount, enum StringPersistence persistence ) +static void set_st_entry( string_table *st, unsigned n, char *str, uint16_t refcount, enum StringPersistence persistence ) { if (persistence == StringPersistent) { @@ -227,9 +220,11 @@ static void set_st_entry( string_table *st, unsigned n, WCHAR *str, uint16_t ref static unsigned _libmsi_id_from_string( const string_table *st, const char *buffer, unsigned *id ) { - unsigned sz; + size_t sz; unsigned r = LIBMSI_RESULT_INVALID_PARAMETER; - WCHAR *str; + char *str; + int codepage; + GIConv cpconv; TRACE("Finding string %s in string table\n", debugstr_a(buffer) ); @@ -239,24 +234,24 @@ static unsigned _libmsi_id_from_string( const string_table *st, const char *buff return LIBMSI_RESULT_SUCCESS; } - sz = MultiByteToWideChar( st->codepage, 0, buffer, -1, NULL, 0 ); - if( sz <= 0 ) - return r; - str = msi_alloc( sz*sizeof(WCHAR) ); + codepage = st->codepage ? st->codepage : gsf_msole_iconv_win_codepage(); + cpconv = gsf_msole_iconv_open_codepage_for_export(codepage); + str = g_convert_with_iconv(buffer, -1, cpconv, NULL, &sz, NULL); + g_iconv_close(cpconv); if( !str ) - return LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - MultiByteToWideChar( st->codepage, 0, buffer, -1, str, sz ); + return r; - r = _libmsi_id_from_stringW( st, str, id ); + r = _libmsi_id_from_string_utf8( st, str, id ); msi_free( str ); - return r; } static int msi_addstring( string_table *st, unsigned n, const char *data, int len, uint16_t refcount, enum StringPersistence persistence ) { - WCHAR *str; - int sz; + char *str; + size_t sz; + int codepage; + GIConv cpconv; if( !data ) return 0; @@ -290,31 +285,27 @@ static int msi_addstring( string_table *st, unsigned n, const char *data, int le } /* allocate a new string */ - if( len < 0 ) - len = strlen(data); - sz = MultiByteToWideChar( st->codepage, 0, data, len, NULL, 0 ); - str = msi_alloc( (sz+1)*sizeof(WCHAR) ); - if( !str ) - return -1; - MultiByteToWideChar( st->codepage, 0, data, len, str, sz ); - str[sz] = 0; + codepage = st->codepage ? st->codepage : gsf_msole_iconv_win_codepage(); + cpconv = gsf_msole_iconv_open_for_import(codepage); + str = g_convert_with_iconv(data, len, cpconv, NULL, &sz, NULL); + g_iconv_close(cpconv); set_st_entry( st, n, str, refcount, persistence ); return n; } -int _libmsi_add_string( string_table *st, const WCHAR *data, int len, uint16_t refcount, enum StringPersistence persistence ) +int _libmsi_add_string( string_table *st, const char *data, int len, uint16_t refcount, enum StringPersistence persistence ) { unsigned n; - WCHAR *str; + char *str; if( !data ) return 0; if( !data[0] ) return 0; - if( _libmsi_id_from_stringW( st, data, &n ) == LIBMSI_RESULT_SUCCESS ) + if( _libmsi_id_from_string_utf8( st, data, &n ) == LIBMSI_RESULT_SUCCESS ) { if (persistence == StringPersistent) st->strings[n].persistent_refcount += refcount; @@ -329,13 +320,13 @@ int _libmsi_add_string( string_table *st, const WCHAR *data, int len, uint16_t r /* allocate a new string */ if(len<0) - len = strlenW(data); - TRACE("%s, n = %d len = %d\n", debugstr_w(data), n, len ); + len = strlen(data); + TRACE("%s, n = %d len = %d\n", debugstr_a(data), n, len ); - str = msi_alloc( (len+1)*sizeof(WCHAR) ); + str = msi_alloc( (len+1)*sizeof(char) ); if( !str ) return -1; - memcpy( str, data, len*sizeof(WCHAR) ); + memcpy( str, data, len*sizeof(char) ); str[len] = 0; set_st_entry( st, n, str, refcount, persistence ); @@ -344,7 +335,7 @@ int _libmsi_add_string( string_table *st, const WCHAR *data, int len, uint16_t r } /* find the string identified by an id - return null if there's none */ -const WCHAR *msi_string_lookup_id( const string_table *st, unsigned id ) +const char *msi_string_lookup_id( const string_table *st, unsigned id ) { if( id == 0 ) return szEmpty; @@ -367,45 +358,52 @@ const WCHAR *msi_string_lookup_id( const string_table *st, unsigned id ) * [in/out] sz - number of bytes available in the buffer on input * number of bytes used on output * - * Returned string is not nul terminated. + * Returned string is not NUL-terminated. */ static unsigned _libmsi_string_id( const string_table *st, unsigned id, char *buffer, unsigned *sz ) { - unsigned len, lenW; - const WCHAR *str; + const char *str_utf8; + char *str; + size_t len; + GIConv cpconv; + int codepage; TRACE("Finding string %d of %d\n", id, st->maxcount); - str = msi_string_lookup_id( st, id ); - if( !str ) + str_utf8 = msi_string_lookup_id( st, id ); + if( !str_utf8 ) return LIBMSI_RESULT_FUNCTION_FAILED; - lenW = strlenW( str ); - len = WideCharToMultiByte( st->codepage, 0, str, lenW, NULL, 0, NULL, NULL ); + codepage = st->codepage ? st->codepage : gsf_msole_iconv_win_codepage(); + cpconv = gsf_msole_iconv_open_codepage_for_export(codepage); + str = g_convert_with_iconv(str_utf8, -1, cpconv, NULL, &len, NULL); + g_iconv_close(cpconv); if( *sz < len ) { *sz = len; return LIBMSI_RESULT_MORE_DATA; } - *sz = WideCharToMultiByte( st->codepage, 0, str, lenW, buffer, *sz, NULL, NULL ); + *sz = len; + memcpy(buffer, str, len); + msi_free(str); return LIBMSI_RESULT_SUCCESS; } /* - * _libmsi_id_from_stringW + * _libmsi_id_from_string_utf8 * * [in] st - pointer to the string table * [in] str - string to find in the string table * [out] id - id of the string, if found */ -unsigned _libmsi_id_from_stringW( const string_table *st, const WCHAR *str, unsigned *id ) +unsigned _libmsi_id_from_string_utf8( const string_table *st, const char *str, unsigned *id ) { int i, c, low = 0, high = st->sortcount - 1; while (low <= high) { i = (low + high) / 2; - c = strcmpW( str, st->strings[st->sorted[i]].str ); + c = strcmp( str, st->strings[st->sorted[i]].str ); if (c < 0) high = i - 1; @@ -423,11 +421,17 @@ unsigned _libmsi_id_from_stringW( const string_table *st, const WCHAR *str, unsi static void string_totalsize( const string_table *st, unsigned *datasize, unsigned *poolsize ) { - unsigned i, len, holesize; + unsigned i, holesize; + size_t len; + int codepage; + GIConv cpconv; + char *str; if( st->strings[0].str || st->strings[0].persistent_refcount || st->strings[0].nonpersistent_refcount) ERR("oops. element 0 has a string\n"); + codepage = st->codepage ? st->codepage : gsf_msole_iconv_win_codepage(); + *poolsize = 4; *datasize = 0; holesize = 0; @@ -435,16 +439,16 @@ static void string_totalsize( const string_table *st, unsigned *datasize, unsign { if( !st->strings[i].persistent_refcount ) { - TRACE("[%u] nonpersistent = %s\n", i, debugstr_w(st->strings[i].str)); + TRACE("[%u] nonpersistent = %s\n", i, debugstr_a(st->strings[i].str)); (*poolsize) += 4; } else if( st->strings[i].str ) { - TRACE("[%u] = %s\n", i, debugstr_w(st->strings[i].str)); - len = WideCharToMultiByte( st->codepage, 0, - st->strings[i].str, -1, NULL, 0, NULL, NULL); - if( len ) - len--; + TRACE("[%u] = %s\n", i, debugstr_a(st->strings[i].str)); + cpconv = gsf_msole_iconv_open_codepage_for_export(codepage); + str = g_convert_with_iconv( st->strings[i].str, -1, cpconv, NULL, &len, NULL); + g_iconv_close(cpconv); + msi_free(str); (*datasize) += len; if (len>0xffff) (*poolsize) += 4; @@ -467,7 +471,7 @@ string_table *msi_init_string_table( unsigned *bytes_per_strref ) return st; } -string_table *msi_load_string_table( IStorage *stg, unsigned *bytes_per_strref ) +string_table *msi_load_string_table( GsfInfile *stg, unsigned *bytes_per_strref ) { string_table *st = NULL; char *data = NULL; diff --git a/libmsi/table.c b/libmsi/table.c index 0d1c604..9871958 100644 --- a/libmsi/table.c +++ b/libmsi/table.c @@ -21,27 +21,16 @@ #include <stdarg.h> #include <assert.h> -#define COBJMACROS -#define NONAMELESSUNION -#define NONAMELESSSTRUCT - -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" -#include "winnls.h" #include "msipriv.h" #include "query.h" #include "debug.h" -#include "unicode.h" #define LibmsiTable_HASH_TABLE_SIZE 37 -static const WCHAR szDot[] = {'.',0}; +static const char szDot[] = "."; typedef struct _LibmsiColumnHashEntry { @@ -52,9 +41,9 @@ typedef struct _LibmsiColumnHashEntry typedef struct _LibmsiColumnInfo { - const WCHAR *tablename; + const char *tablename; unsigned number; - const WCHAR *colname; + const char *colname; unsigned type; unsigned offset; int ref_count; @@ -72,15 +61,15 @@ struct _LibmsiTable unsigned col_count; LibmsiCondition persistent; int ref_count; - WCHAR name[1]; + char name[1]; }; /* information for default tables */ -static const WCHAR szTables[] = {'_','T','a','b','l','e','s',0}; -static const WCHAR szTable[] = {'T','a','b','l','e',0}; -static const WCHAR szColumns[] = {'_','C','o','l','u','m','n','s',0}; -static const WCHAR szNumber[] = {'N','u','m','b','e','r',0}; -static const WCHAR szType[] = {'T','y','p','e',0}; +static const char szTables[] = "_Tables"; +static const char szTable[] = "Table"; +static const char szColumns[] = "_Columns"; +static const char szNumber[] = "Number"; +static const char szType[] = "Type"; static const LibmsiColumnInfo _Columns_cols[4] = { { szColumns, 1, szTable, MSITYPE_VALID | MSITYPE_STRING | MSITYPE_KEY | 64, 0, 0, 0, NULL }, @@ -127,16 +116,15 @@ static int utf2mime(int x) return -1; } -WCHAR *encode_streamname(bool bTable, const WCHAR *in) +char *encode_streamname(bool bTable, const char *in) { unsigned count = MAX_STREAM_NAME; unsigned ch, next; - WCHAR *out_wc; - CHAR *out; - CHAR *p; + char *out; + char *p; if( !bTable ) - count = strlenW( in )+2; + count = strlen( in )+2; if (!(out = msi_alloc( count*3 ))) return NULL; p = out; @@ -154,11 +142,7 @@ WCHAR *encode_streamname(bool bTable, const WCHAR *in) if( !ch ) { *p = ch; - - /* Convert UTF-8 to WCHAR */ - out_wc = strdupUTF8toW(out); - msi_free(out); - return out_wc; + return out; } if( ( ch < 0x80 ) && ( utf2mime(ch) >= 0 ) ) { @@ -183,11 +167,10 @@ WCHAR *encode_streamname(bool bTable, const WCHAR *in) in++; } } else { - // *p++ = ch; - p += WideCharToMultiByte( CP_UTF8, 0, &ch, 1, p, 5, NULL, NULL ); + *p++ = ch; } } - ERR("Failed to encode stream name (%s)\n",debugstr_w(in)); + ERR("Failed to encode stream name (%s)\n",debugstr_a(in)); msi_free( out ); return NULL; } @@ -205,14 +188,11 @@ static int mime2utf(int x) return '_'; } -void decode_streamname(const WCHAR *in, WCHAR *out) +void decode_streamname(const char *in, char *out) { unsigned count = 0; - uint8_t *enc_utf8 = strdupWtoUTF8(in); - uint8_t *p = enc_utf8; - - uint8_t *dec_utf8 = strdup(enc_utf8); - uint8_t *q = dec_utf8; + const uint8_t *p = (const uint8_t *)in; + uint8_t *q = (uint8_t *)out; while ( *p ) { @@ -246,97 +226,74 @@ void decode_streamname(const WCHAR *in, WCHAR *out) count++; } *q = 0; - msi_free(enc_utf8); - - /* convert UTF8 to WCHAR */ - MultiByteToWideChar( CP_UTF8, 0, dec_utf8, -1, out, count + 1 ); - msi_free(dec_utf8); } -void enum_stream_names( IStorage *stg ) +void enum_stream_names( GsfInfile *stg ) { - IEnumSTATSTG *stgenum = NULL; - HRESULT r; - STATSTG stat; - unsigned n, count; - WCHAR name[0x40]; - - r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum ); - if( FAILED( r ) ) - return; + unsigned n, i; + char name[0x40]; - n = 0; - while( 1 ) + n = gsf_infile_num_children(stg); + for (i = 0; i < n; i++) { - count = 0; - r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count ); - if( FAILED( r ) || !count ) - break; - decode_streamname( stat.pwcsName, name ); + const char *stname = gsf_infile_name_by_index(stg, i); + decode_streamname( stname, name ); TRACE("stream %2d -> %s %s\n", n, - debugstr_w(stat.pwcsName), debugstr_w(name) ); - CoTaskMemFree( stat.pwcsName ); - n++; + debugstr_a(stname), debugstr_a(name) ); } - - IEnumSTATSTG_Release( stgenum ); } -unsigned read_stream_data( IStorage *stg, const WCHAR *stname, +unsigned read_stream_data( GsfInfile *stg, const char *stname, uint8_t **pdata, unsigned *psz ) { - HRESULT r; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - VOID *data; - unsigned sz, count; - IStream *stm = NULL; - STATSTG stat; - WCHAR *encname; + void *data; + unsigned sz; + GsfInput *stm = NULL; + char *encname; encname = encode_streamname(true, stname); - TRACE("%s -> %s\n",debugstr_w(stname),debugstr_w(encname)); + TRACE("%s -> %s\n",debugstr_a(stname),debugstr_a(encname)); if ( !stg ) return LIBMSI_RESULT_FUNCTION_FAILED; - r = IStorage_OpenStream(stg, encname, NULL, - STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm); - msi_free( encname ); - if( FAILED( r ) ) + stm = gsf_infile_child_by_name(stg, encname ); + msi_free(encname); + if( !stm ) { - WARN("open stream failed r = %08x - empty table?\n", r); + WARN("open stream failed - empty table?\n"); return ret; } - r = IStream_Stat(stm, &stat, STATFLAG_NONAME ); - if( FAILED( r ) ) - { - WARN("open stream failed r = %08x!\n", r); - goto end; - } - - if( stat.cbSize.QuadPart >> 32 ) + if( gsf_input_size(stm) >> 32 ) { WARN("Too big!\n"); goto end; } - sz = stat.cbSize.QuadPart; - data = msi_alloc( sz ); - if( !data ) + sz = gsf_input_size(stm); + if ( !sz ) { - WARN("couldn't allocate memory r=%08x!\n", r); - ret = LIBMSI_RESULT_NOT_ENOUGH_MEMORY; - goto end; + data = NULL; } - - r = IStream_Read(stm, data, sz, &count ); - if( FAILED( r ) || ( count != sz ) ) + else { - msi_free( data ); - WARN("read stream failed r = %08x!\n", r); - goto end; + data = g_try_malloc( sz ); + if( !data ) + { + WARN("couldn't allocate memory (%u bytes)!\n", sz); + ret = LIBMSI_RESULT_NOT_ENOUGH_MEMORY; + goto end; + } + + if (! gsf_input_read( stm, sz, data )) + { + msi_free( data ); + WARN("read stream failed\n"); + goto end; + } } *pdata = data; @@ -344,70 +301,42 @@ unsigned read_stream_data( IStorage *stg, const WCHAR *stname, ret = LIBMSI_RESULT_SUCCESS; end: - IStream_Release( stm ); + g_object_unref(G_OBJECT(stm)); return ret; } -unsigned write_stream_data( LibmsiDatabase *db, const WCHAR *stname, +unsigned write_stream_data( LibmsiDatabase *db, const char *stname, const void *data, unsigned sz ) { unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; - WCHAR *encname; - HRESULT r; - IStream *stm; - ULARGE_INTEGER size; - LARGE_INTEGER pos; - unsigned count; + char *encname; + GsfOutput *stm; if (!db->outfile) return ret; encname = encode_streamname(true, stname ); - r = IStorage_OpenStream( db->outfile, encname, NULL, - STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, &stm); - if( FAILED(r) ) - { - r = IStorage_CreateStream( db->outfile, encname, - STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm); - } + + stm = gsf_outfile_new_child( db->outfile, encname, false ); msi_free( encname ); - if( FAILED( r ) ) + if( !stm ) { - WARN("open stream failed r = %08x\n", r); + WARN("open stream failed\n"); return ret; } - size.QuadPart = sz; - r = IStream_SetSize( stm, size ); - if( FAILED( r ) ) - { - WARN("Failed to SetSize\n"); - goto end; - } - - pos.QuadPart = 0; - r = IStream_Seek( stm, pos, STREAM_SEEK_SET, NULL ); - if( FAILED( r ) ) + if (! gsf_output_write(stm, sz, data) ) { - WARN("Failed to Seek\n"); + WARN("Failed to Write\n"); goto end; } - if (sz) - { - r = IStream_Write(stm, data, sz, &count ); - if( FAILED( r ) || ( count != sz ) ) - { - WARN("Failed to Write\n"); - goto end; - } - } - ret = LIBMSI_RESULT_SUCCESS; end: - IStream_Release( stm ); + gsf_output_close(GSF_OUTPUT(stm)); + g_object_unref(G_OBJECT(stm)); return ret; } @@ -447,12 +376,12 @@ static unsigned msi_table_get_row_size( LibmsiDatabase *db, const LibmsiColumnIn } /* add this table to the list of cached tables in the database */ -static unsigned read_table_from_storage( LibmsiDatabase *db, LibmsiTable *t, IStorage *stg ) +static unsigned read_table_from_storage( LibmsiDatabase *db, LibmsiTable *t, GsfInfile *stg ) { uint8_t *rawdata = NULL; unsigned rawsize = 0, i, j, row_size, row_size_mem; - TRACE("%s\n",debugstr_w(t->name)); + TRACE("%s\n",debugstr_a(t->name)); row_size = msi_table_get_row_size( db, t->colinfo, t->col_count, db->bytes_per_strref ); row_size_mem = msi_table_get_row_size( db, t->colinfo, t->col_count, LONG_STR_BYTES ); @@ -538,12 +467,12 @@ void free_cached_tables( LibmsiDatabase *db ) } } -static LibmsiTable *find_cached_table( LibmsiDatabase *db, const WCHAR *name ) +static LibmsiTable *find_cached_table( LibmsiDatabase *db, const char *name ) { LibmsiTable *t; LIST_FOR_EACH_ENTRY( t, &db->tables, LibmsiTable, entry ) - if( !strcmpW( name, t->name ) ) + if( !strcmp( name, t->name ) ) return t; return NULL; @@ -561,24 +490,24 @@ static void table_calc_column_offsets( LibmsiDatabase *db, LibmsiColumnInfo *col else colinfo[i].offset = 0; TRACE("column %d is [%s] with type %08x ofs %d\n", - colinfo[i].number, debugstr_w(colinfo[i].colname), + colinfo[i].number, debugstr_a(colinfo[i].colname), colinfo[i].type, colinfo[i].offset); } } -static unsigned get_defaulttablecolumns( LibmsiDatabase *db, const WCHAR *name, LibmsiColumnInfo *colinfo, unsigned *sz ) +static unsigned get_defaulttablecolumns( LibmsiDatabase *db, const char *name, LibmsiColumnInfo *colinfo, unsigned *sz ) { const LibmsiColumnInfo *p; unsigned i, n; - TRACE("%s\n", debugstr_w(name)); + TRACE("%s\n", debugstr_a(name)); - if (!strcmpW( name, szTables )) + if (!strcmp( name, szTables )) { p = _Tables_cols; n = 1; } - else if (!strcmpW( name, szColumns )) + else if (!strcmp( name, szColumns )) { p = _Columns_cols; n = 4; @@ -595,9 +524,9 @@ static unsigned get_defaulttablecolumns( LibmsiDatabase *db, const WCHAR *name, return LIBMSI_RESULT_SUCCESS; } -static unsigned get_tablecolumns( LibmsiDatabase *db, const WCHAR *szTableName, LibmsiColumnInfo *colinfo, unsigned *sz ); +static unsigned get_tablecolumns( LibmsiDatabase *db, const char *szTableName, LibmsiColumnInfo *colinfo, unsigned *sz ); -static unsigned table_get_column_info( LibmsiDatabase *db, const WCHAR *name, LibmsiColumnInfo **pcols, unsigned *pcount ) +static unsigned table_get_column_info( LibmsiDatabase *db, const char *name, LibmsiColumnInfo **pcols, unsigned *pcount ) { unsigned r, column_count = 0; LibmsiColumnInfo *columns; @@ -614,7 +543,7 @@ static unsigned table_get_column_info( LibmsiDatabase *db, const WCHAR *name, Li if (!column_count) return LIBMSI_RESULT_INVALID_PARAMETER; - TRACE("table %s found\n", debugstr_w(name)); + TRACE("table %s found\n", debugstr_a(name)); columns = msi_alloc( column_count * sizeof(LibmsiColumnInfo) ); if (!columns) @@ -630,33 +559,33 @@ static unsigned table_get_column_info( LibmsiDatabase *db, const WCHAR *name, Li return r; } -unsigned _libmsi_open_table( LibmsiDatabase *db, const WCHAR *name, bool encoded ) +unsigned _libmsi_open_table( LibmsiDatabase *db, const char *name, bool encoded ) { - WCHAR decname[0x40]; + char decname[0x40]; LibmsiTable *table; if (encoded) { - assert(name[0] == 0x4840); + assert(name[0] == 0xe4 && name[1] == 0xa1 && name[2] == 0x80); decode_streamname( name + 1, decname ); name = decname; } - table = msi_alloc_zero( sizeof(LibmsiTable) + strlenW( name ) * sizeof(WCHAR) ); + table = msi_alloc_zero( sizeof(LibmsiTable) + strlen( name ) * sizeof(char) ); if (!table) return LIBMSI_RESULT_FUNCTION_FAILED; table->persistent = LIBMSI_CONDITION_TRUE; - strcpyW( table->name, name ); + strcpy( table->name, name ); - if (!strcmpW( name, szTables ) || !strcmpW( name, szColumns )) + if (!strcmp( name, szTables ) || !strcmp( name, szColumns )) table->persistent = LIBMSI_CONDITION_NONE; list_add_head( &db->tables, &table->entry ); return LIBMSI_RESULT_SUCCESS; } -static unsigned get_table( LibmsiDatabase *db, const WCHAR *name, LibmsiTable **table_ret ) +static unsigned get_table( LibmsiDatabase *db, const char *name, LibmsiTable **table_ret ) { LibmsiTable *table; unsigned r; @@ -707,12 +636,12 @@ static unsigned read_table_int( uint8_t *const *data, unsigned row, unsigned col return ret; } -static unsigned get_tablecolumns( LibmsiDatabase *db, const WCHAR *szTableName, LibmsiColumnInfo *colinfo, unsigned *sz ) +static unsigned get_tablecolumns( LibmsiDatabase *db, const char *szTableName, LibmsiColumnInfo *colinfo, unsigned *sz ) { unsigned r, i, n = 0, table_id, count, maxcount = *sz; LibmsiTable *table = NULL; - TRACE("%s\n", debugstr_w(szTableName)); + TRACE("%s\n", debugstr_a(szTableName)); /* first check if there is a default table with that name */ r = get_defaulttablecolumns( db, szTableName, colinfo, sz ); @@ -727,10 +656,10 @@ static unsigned get_tablecolumns( LibmsiDatabase *db, const WCHAR *szTableName, } /* convert table and column names to IDs from the string table */ - r = _libmsi_id_from_stringW( db->strings, szTableName, &table_id ); + r = _libmsi_id_from_string_utf8( db->strings, szTableName, &table_id ); if (r != LIBMSI_RESULT_SUCCESS) { - WARN("Couldn't find id for %s\n", debugstr_w(szTableName)); + WARN("Couldn't find id for %s\n", debugstr_a(szTableName)); return r; } TRACE("Table id is %d, row count is %d\n", table_id, table->row_count); @@ -771,11 +700,11 @@ static unsigned get_tablecolumns( LibmsiDatabase *db, const WCHAR *szTableName, } n++; } - TRACE("%s has %d columns\n", debugstr_w(szTableName), n); + TRACE("%s has %d columns\n", debugstr_a(szTableName), n); if (colinfo && n != maxcount) { - ERR("missing column in table %s\n", debugstr_w(szTableName)); + ERR("missing column in table %s\n", debugstr_a(szTableName)); msi_free_colinfo( colinfo, maxcount ); return LIBMSI_RESULT_FUNCTION_FAILED; } @@ -784,7 +713,7 @@ static unsigned get_tablecolumns( LibmsiDatabase *db, const WCHAR *szTableName, return LIBMSI_RESULT_SUCCESS; } -unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *col_info, +unsigned msi_create_table( LibmsiDatabase *db, const char *name, column_info *col_info, LibmsiCondition persistent ) { enum StringPersistence string_persistence = (persistent) ? StringPersistent : StringNonPersistent; @@ -798,11 +727,11 @@ unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *c /* only add tables that don't exist already */ if( table_view_exists(db, name ) ) { - WARN("table %s exists\n", debugstr_w(name)); + WARN("table %s exists\n", debugstr_a(name)); return LIBMSI_RESULT_BAD_QUERY_SYNTAX; } - table = msi_alloc( sizeof (LibmsiTable) + strlenW(name)*sizeof (WCHAR) ); + table = msi_alloc( sizeof (LibmsiTable) + strlen(name)*sizeof (char) ); if( !table ) return LIBMSI_RESULT_FUNCTION_FAILED; @@ -813,7 +742,7 @@ unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *c table->colinfo = NULL; table->col_count = 0; table->persistent = persistent; - strcpyW( table->name, name ); + strcpy( table->name, name ); for( col = col_info; col; col = col->next ) table->col_count++; @@ -858,7 +787,7 @@ unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *c if( !rec ) goto err; - r = _libmsi_record_set_stringW( rec, 1, name ); + r = libmsi_record_set_string( rec, 1, name ); if( r ) goto err; @@ -889,7 +818,7 @@ unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *c if( !rec ) goto err; - r = _libmsi_record_set_stringW( rec, 1, name ); + r = libmsi_record_set_string( rec, 1, name ); if( r ) goto err; @@ -904,7 +833,7 @@ unsigned msi_create_table( LibmsiDatabase *db, const WCHAR *name, column_info *c if( r ) goto err; - r = _libmsi_record_set_stringW( rec, 3, col->column ); + r = libmsi_record_set_string( rec, 3, col->column ); if( r ) goto err; @@ -951,10 +880,10 @@ static unsigned save_table( LibmsiDatabase *db, const LibmsiTable *t, unsigned b * we can just skip them if they are empty. However, always * save the Tables stream. */ - if ( t->row_count == 0 && strcmpW(t->name, szTables) ) + if ( t->row_count == 0 && strcmp(t->name, szTables) ) return LIBMSI_RESULT_SUCCESS; - TRACE("Saving %s\n", debugstr_w( t->name ) ); + TRACE("Saving %s\n", debugstr_a( t->name ) ); row_size = msi_table_get_row_size( db, t->colinfo, t->col_count, bytes_per_strref ); row_count = t->row_count; @@ -1019,7 +948,7 @@ err: return r; } -static void msi_update_table_columns( LibmsiDatabase *db, const WCHAR *name ) +static void msi_update_table_columns( LibmsiDatabase *db, const char *name ) { LibmsiTable *table; unsigned size, offset, old_count; @@ -1046,26 +975,26 @@ static void msi_update_table_columns( LibmsiDatabase *db, const WCHAR *name ) } /* try to find the table name in the _Tables table */ -bool table_view_exists( LibmsiDatabase *db, const WCHAR *name ) +bool table_view_exists( LibmsiDatabase *db, const char *name ) { unsigned r, table_id, i; LibmsiTable *table; - if( !strcmpW( name, szTables ) || !strcmpW( name, szColumns ) || - !strcmpW( name, szStreams ) || !strcmpW( name, szStorages ) ) + if( !strcmp( name, szTables ) || !strcmp( name, szColumns ) || + !strcmp( name, szStreams ) || !strcmp( name, szStorages ) ) return true; - r = _libmsi_id_from_stringW( db->strings, name, &table_id ); + r = _libmsi_id_from_string_utf8( db->strings, name, &table_id ); if( r != LIBMSI_RESULT_SUCCESS ) { - TRACE("Couldn't find id for %s\n", debugstr_w(name)); + TRACE("Couldn't find id for %s\n", debugstr_a(name)); return false; } r = get_table( db, szTables, &table ); if( r != LIBMSI_RESULT_SUCCESS ) { - ERR("table %s not available\n", debugstr_w(szTables)); + ERR("table %s not available\n", debugstr_a(szTables)); return false; } @@ -1088,7 +1017,7 @@ typedef struct _LibmsiTableView LibmsiColumnInfo *columns; unsigned num_cols; unsigned row_size; - WCHAR name[1]; + char name[1]; } LibmsiTableView; static unsigned table_view_fetch_int( LibmsiView *view, unsigned row, unsigned col, unsigned *val ) @@ -1128,33 +1057,33 @@ static unsigned table_view_fetch_int( LibmsiView *view, unsigned row, unsigned c return LIBMSI_RESULT_SUCCESS; } -static unsigned msi_stream_name( const LibmsiTableView *tv, unsigned row, WCHAR **pstname ) +static unsigned msi_stream_name( const LibmsiTableView *tv, unsigned row, char **pstname ) { - WCHAR *p; - WCHAR *stname = NULL; + char *p; + char *stname = NULL; unsigned i, r, type, ival; unsigned len; - const WCHAR *sval; + const char *sval; LibmsiView *view = (LibmsiView *) tv; TRACE("%p %d\n", tv, row); - len = strlenW( tv->name ) + 1; - stname = msi_alloc( len*sizeof(WCHAR) ); + len = strlen( tv->name ) + 1; + stname = msi_alloc( len*sizeof(char) ); if ( !stname ) { r = LIBMSI_RESULT_OUTOFMEMORY; goto err; } - strcpyW( stname, tv->name ); + strcpy( stname, tv->name ); for ( i = 0; i < tv->num_cols; i++ ) { type = tv->columns[i].type; if ( type & MSITYPE_KEY ) { - WCHAR number[0x20]; + char number[0x20]; r = table_view_fetch_int( view, row, i+1, &ival ); if ( r != LIBMSI_RESULT_SUCCESS ) @@ -1171,16 +1100,16 @@ static unsigned msi_stream_name( const LibmsiTableView *tv, unsigned row, WCHAR } else { - static const WCHAR fmt[] = { '%','d',0 }; + static const char fmt[] = "%d"; unsigned n = bytes_per_column( tv->db, &tv->columns[i], LONG_STR_BYTES ); switch( n ) { case 2: - sprintfW( number, fmt, ival-0x8000 ); + sprintf( number, fmt, ival-0x8000 ); break; case 4: - sprintfW( number, fmt, ival^0x80000000 ); + sprintf( number, fmt, ival^0x80000000 ); break; default: ERR( "oops - unknown column width %d\n", n ); @@ -1190,8 +1119,8 @@ static unsigned msi_stream_name( const LibmsiTableView *tv, unsigned row, WCHAR sval = number; } - len += strlenW( szDot ) + strlenW( sval ); - p = msi_realloc ( stname, len*sizeof(WCHAR) ); + len += strlen( szDot ) + strlen( sval ); + p = msi_realloc ( stname, len*sizeof(char) ); if ( !p ) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -1199,8 +1128,8 @@ static unsigned msi_stream_name( const LibmsiTableView *tv, unsigned row, WCHAR } stname = p; - strcatW( stname, szDot ); - strcatW( stname, sval ); + strcat( stname, szDot ); + strcat( stname, sval ); } else continue; @@ -1220,12 +1149,12 @@ err: * the name of the stream in the same table, and the table name * which may not be available at higher levels of the query */ -static unsigned table_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, IStream **stm ) +static unsigned table_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm ) { LibmsiTableView *tv = (LibmsiTableView*)view; unsigned r; - WCHAR *encname; - WCHAR *full_name = NULL; + char *encname; + char *full_name = NULL; if( !view->ops->fetch_int ) return LIBMSI_RESULT_INVALID_PARAMETER; @@ -1240,7 +1169,7 @@ static unsigned table_view_fetch_stream( LibmsiView *view, unsigned row, unsigne encname = encode_streamname( false, full_name ); r = msi_get_raw_stream( tv->db, encname, stm ); if( r ) - ERR("fetching stream %s, error = %d\n",debugstr_w(full_name), r); + ERR("fetching stream %s, error = %d\n",debugstr_a(full_name), r); msi_free( full_name ); msi_free( encname ); @@ -1294,28 +1223,25 @@ static unsigned table_view_get_row( LibmsiView *view, unsigned row, LibmsiRecord return msi_view_get_row(tv->db, view, row, rec); } -static unsigned _libmsi_add_stream( LibmsiDatabase *db, const WCHAR *name, IStream *data ) +static unsigned _libmsi_add_stream( LibmsiDatabase *db, const char *name, GsfInput *data ) { - static const WCHAR insert[] = { - 'I','N','S','E','R','T',' ','I','N','T','O',' ', - '`','_','S','t','r','e','a','m','s','`',' ', - '(','`','N','a','m','e','`',',','`','D','a','t','a','`',')',' ', - 'V','A','L','U','E','S',' ','(','?',',','?',')',0}; + static const char insert[] = + "INSERT INTO `_Streams`(`Name`, `Data`) VALUES (?, ?)"; LibmsiQuery *query = NULL; LibmsiRecord *rec; unsigned r; - TRACE("%p %s %p\n", db, debugstr_w(name), data); + TRACE("%p %s %p\n", db, debugstr_a(name), data); rec = libmsi_record_new( 2 ); if ( !rec ) return LIBMSI_RESULT_OUTOFMEMORY; - r = _libmsi_record_set_stringW( rec, 1, name ); + r = libmsi_record_set_string( rec, 1, name ); if ( r != LIBMSI_RESULT_SUCCESS ) goto err; - r = _libmsi_record_set_IStream( rec, 2, data ); + r = _libmsi_record_set_gsf_input( rec, 2, data ); if ( r != LIBMSI_RESULT_SUCCESS ) goto err; @@ -1349,10 +1275,10 @@ static unsigned get_table_value_from_record( LibmsiTableView *tv, LibmsiRecord * } else if ( columninfo.type & MSITYPE_STRING ) { - const WCHAR *sval = _libmsi_record_get_string_raw( rec, iField ); + const char *sval = _libmsi_record_get_string_raw( rec, iField ); if (sval) { - r = _libmsi_id_from_stringW(tv->db->strings, sval, pvalue); + r = _libmsi_id_from_string_utf8(tv->db->strings, sval, pvalue); if (r != LIBMSI_RESULT_SUCCESS) return LIBMSI_RESULT_NOT_FOUND; } @@ -1406,25 +1332,25 @@ static unsigned table_view_set_row( LibmsiView *view, unsigned row, LibmsiRecord r = get_table_value_from_record (tv, rec, i + 1, &val); if ( MSITYPE_IS_BINARY(tv->columns[ i ].type) ) { - IStream *stm; - WCHAR *stname; + GsfInput *stm; + char *stname; if ( r != LIBMSI_RESULT_SUCCESS ) return LIBMSI_RESULT_FUNCTION_FAILED; - r = _libmsi_record_get_IStream( rec, i + 1, &stm ); + r = _libmsi_record_get_gsf_input( rec, i + 1, &stm ); if ( r != LIBMSI_RESULT_SUCCESS ) return r; r = msi_stream_name( tv, row, &stname ); if ( r != LIBMSI_RESULT_SUCCESS ) { - IStream_Release( stm ); + g_object_unref(G_OBJECT(stm)); return r; } r = _libmsi_add_stream( tv->db, stname, stm ); - IStream_Release( stm ); + g_object_unref(G_OBJECT(stm)); msi_free ( stname ); if ( r != LIBMSI_RESULT_SUCCESS ) @@ -1436,7 +1362,7 @@ static unsigned table_view_set_row( LibmsiView *view, unsigned row, LibmsiRecord if ( r != LIBMSI_RESULT_SUCCESS ) { - const WCHAR *sval = _libmsi_record_get_string_raw( rec, i + 1 ); + const char *sval = _libmsi_record_get_string_raw( rec, i + 1 ); val = _libmsi_add_string( tv->db->strings, sval, -1, 1, persistent ? StringPersistent : StringNonPersistent ); } @@ -1557,8 +1483,8 @@ static unsigned table_view_get_dimensions( LibmsiView *view, unsigned *rows, uns } static unsigned table_view_get_column_info( LibmsiView *view, - unsigned n, const WCHAR **name, unsigned *type, bool *temporary, - const WCHAR **table_name ) + unsigned n, const char **name, unsigned *type, bool *temporary, + const char **table_name ) { LibmsiTableView *tv = (LibmsiTableView*)view; @@ -1606,7 +1532,7 @@ static unsigned table_validate_new( LibmsiTableView *tv, LibmsiRecord *rec, unsi TRACE("skipping binary column\n"); else if ( tv->columns[i].type & MSITYPE_STRING ) { - const WCHAR *str; + const char *str; str = _libmsi_record_get_string_raw( rec, i+1 ); if (str == NULL || str[0] == 0) @@ -1874,7 +1800,7 @@ static unsigned table_view_add_ref(LibmsiView *view) return __sync_add_and_fetch(&tv->table->ref_count, 1); } -static unsigned table_view_remove_column(LibmsiView *view, const WCHAR *table, unsigned number) +static unsigned table_view_remove_column(LibmsiView *view, const char *table, unsigned number) { LibmsiTableView *tv = (LibmsiTableView*)view; LibmsiRecord *rec = NULL; @@ -1885,7 +1811,7 @@ static unsigned table_view_remove_column(LibmsiView *view, const WCHAR *table, u if (!rec) return LIBMSI_RESULT_OUTOFMEMORY; - _libmsi_record_set_stringW(rec, 1, table); + libmsi_record_set_string(rec, 1, table); libmsi_record_set_int(rec, 2, number); r = table_view_create(tv->db, szColumns, &columns); @@ -1945,8 +1871,8 @@ static unsigned table_view_release(LibmsiView *view) return ref; } -static unsigned table_view_add_column(LibmsiView *view, const WCHAR *table, unsigned number, - const WCHAR *column, unsigned type, bool hold) +static unsigned table_view_add_column(LibmsiView *view, const char *table, unsigned number, + const char *column, unsigned type, bool hold) { LibmsiTableView *tv = (LibmsiTableView*)view; LibmsiTable *msitable; @@ -1957,9 +1883,9 @@ static unsigned table_view_add_column(LibmsiView *view, const WCHAR *table, unsi if (!rec) return LIBMSI_RESULT_OUTOFMEMORY; - _libmsi_record_set_stringW(rec, 1, table); + libmsi_record_set_string(rec, 1, table); libmsi_record_set_int(rec, 2, number); - _libmsi_record_set_stringW(rec, 3, column); + libmsi_record_set_string(rec, 3, column); libmsi_record_set_int(rec, 4, type); r = table_view_insert_row(&tv->view, rec, -1, false); @@ -1974,7 +1900,7 @@ static unsigned table_view_add_column(LibmsiView *view, const WCHAR *table, unsi msitable = find_cached_table(tv->db, table); for (i = 0; i < msitable->col_count; i++) { - if (!strcmpW( msitable->colinfo[i].colname, column )) + if (!strcmp( msitable->colinfo[i].colname, column )) { __sync_add_and_fetch(&msitable->colinfo[i].ref_count, 1); break; @@ -1994,7 +1920,7 @@ static unsigned table_view_drop(LibmsiView *view) unsigned r, row; int i; - TRACE("dropping table %s\n", debugstr_w(tv->name)); + TRACE("dropping table %s\n", debugstr_a(tv->name)); for (i = tv->table->col_count - 1; i >= 0; i--) { @@ -2008,7 +1934,7 @@ static unsigned table_view_drop(LibmsiView *view) if (!rec) return LIBMSI_RESULT_OUTOFMEMORY; - _libmsi_record_set_stringW(rec, 1, tv->name); + libmsi_record_set_string(rec, 1, tv->name); r = table_view_create(tv->db, szTables, &tables); if (r != LIBMSI_RESULT_SUCCESS) @@ -2054,19 +1980,19 @@ static const LibmsiViewOps table_ops = table_view_drop, }; -unsigned table_view_create( LibmsiDatabase *db, const WCHAR *name, LibmsiView **view ) +unsigned table_view_create( LibmsiDatabase *db, const char *name, LibmsiView **view ) { LibmsiTableView *tv ; unsigned r, sz; - TRACE("%p %s %p\n", db, debugstr_w(name), view ); + TRACE("%p %s %p\n", db, debugstr_a(name), view ); - if ( !strcmpW( name, szStreams ) ) + if ( !strcmp( name, szStreams ) ) return streams_view_create( db, view ); - else if ( !strcmpW( name, szStorages ) ) + else if ( !strcmp( name, szStorages ) ) return storages_view_create( db, view ); - sz = sizeof *tv + strlenW(name)*sizeof name[0] ; + sz = sizeof *tv + strlen(name)*sizeof name[0] ; tv = msi_alloc_zero( sz ); if( !tv ) return LIBMSI_RESULT_FUNCTION_FAILED; @@ -2088,10 +2014,10 @@ unsigned table_view_create( LibmsiDatabase *db, const WCHAR *name, LibmsiView ** tv->num_cols = tv->table->col_count; tv->row_size = msi_table_get_row_size( db, tv->table->colinfo, tv->table->col_count, LONG_STR_BYTES ); - TRACE("%s one row is %d bytes\n", debugstr_w(name), tv->row_size ); + TRACE("%s one row is %d bytes\n", debugstr_a(name), tv->row_size ); *view = (LibmsiView*) tv; - strcpyW( tv->name, name ); + strcpy( tv->name, name ); return LIBMSI_RESULT_SUCCESS; } @@ -2113,14 +2039,14 @@ unsigned _libmsi_database_commit_tables( LibmsiDatabase *db, unsigned bytes_per_ if( r != LIBMSI_RESULT_SUCCESS ) { WARN("failed to load table %s (r=%08x)\n", - debugstr_w(table->name), r); + debugstr_a(table->name), r); return r; } r = save_table( db, table, bytes_per_strref ); if( r != LIBMSI_RESULT_SUCCESS ) { WARN("failed to save table %s (r=%08x)\n", - debugstr_w(table->name), r); + debugstr_a(table->name), r); return r; } list_remove(&table->entry); @@ -2130,12 +2056,12 @@ unsigned _libmsi_database_commit_tables( LibmsiDatabase *db, unsigned bytes_per_ return r; } -LibmsiCondition _libmsi_database_is_table_persistent( LibmsiDatabase *db, const WCHAR *table ) +LibmsiCondition _libmsi_database_is_table_persistent( LibmsiDatabase *db, const char *table ) { LibmsiTable *t; unsigned r; - TRACE("%p %s\n", db, debugstr_w(table)); + TRACE("%p %s\n", db, debugstr_a(table)); if (!table) return LIBMSI_CONDITION_ERROR; @@ -2157,25 +2083,25 @@ static unsigned read_raw_int(const uint8_t *data, unsigned col, unsigned bytes) return ret; } -static unsigned msi_record_encoded_stream_name( const LibmsiTableView *tv, LibmsiRecord *rec, WCHAR **pstname ) +static unsigned msi_record_encoded_stream_name( const LibmsiTableView *tv, LibmsiRecord *rec, char **pstname ) { - WCHAR *stname = NULL; - WCHAR *sval; - WCHAR *p; + char *stname = NULL; + char *sval; + char *p; unsigned len; unsigned i, r; TRACE("%p %p\n", tv, rec); - len = strlenW( tv->name ) + 1; - stname = msi_alloc( len*sizeof(WCHAR) ); + len = strlen( tv->name ) + 1; + stname = msi_alloc( len*sizeof(char) ); if ( !stname ) { r = LIBMSI_RESULT_OUTOFMEMORY; goto err; } - strcpyW( stname, tv->name ); + strcpy( stname, tv->name ); for ( i = 0; i < tv->num_cols; i++ ) { @@ -2188,8 +2114,8 @@ static unsigned msi_record_encoded_stream_name( const LibmsiTableView *tv, Libms goto err; } - len += strlenW( szDot ) + strlenW ( sval ); - p = msi_realloc ( stname, len*sizeof(WCHAR) ); + len += strlen( szDot ) + strlen ( sval ); + p = msi_realloc ( stname, len*sizeof(char) ); if ( !p ) { r = LIBMSI_RESULT_OUTOFMEMORY; @@ -2197,8 +2123,8 @@ static unsigned msi_record_encoded_stream_name( const LibmsiTableView *tv, Libms } stname = p; - strcatW( stname, szDot ); - strcatW( stname, sval ); + strcat( stname, szDot ); + strcat( stname, sval ); msi_free( sval ); } @@ -2218,7 +2144,7 @@ err: } static LibmsiRecord *msi_get_transform_record( const LibmsiTableView *tv, const string_table *st, - IStorage *stg, + GsfInfile *stg, const uint8_t *rawdata, unsigned bytes_per_strref ) { unsigned i, val, ofs = 0; @@ -2244,8 +2170,8 @@ static LibmsiRecord *msi_get_transform_record( const LibmsiTableView *tv, const if( MSITYPE_IS_BINARY(tv->columns[i].type) ) { - WCHAR *encname; - IStream *stm = NULL; + char *encname; + GsfInput *stm = NULL; unsigned r; ofs += bytes_per_column( tv->db, &columns[i], bytes_per_strref ); @@ -2254,8 +2180,7 @@ static LibmsiRecord *msi_get_transform_record( const LibmsiTableView *tv, const if ( r != LIBMSI_RESULT_SUCCESS ) return NULL; - r = IStorage_OpenStream( stg, encname, NULL, - STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm ); + stm = gsf_infile_child_by_name( stg, encname ); if ( r != LIBMSI_RESULT_SUCCESS ) { msi_free( encname ); @@ -2263,17 +2188,17 @@ static LibmsiRecord *msi_get_transform_record( const LibmsiTableView *tv, const } _libmsi_record_load_stream( rec, i+1, stm ); - TRACE(" field %d [%s]\n", i+1, debugstr_w(encname)); + TRACE(" field %d [%s]\n", i+1, debugstr_a(encname)); msi_free( encname ); } else if( columns[i].type & MSITYPE_STRING ) { - const WCHAR *sval; + const char *sval; val = read_raw_int(rawdata, ofs, bytes_per_strref); sval = msi_string_lookup_id( st, val ); - _libmsi_record_set_stringW( rec, i+1, sval ); - TRACE(" field %d [%s]\n", i+1, debugstr_w(sval)); + libmsi_record_set_string( rec, i+1, sval ); + TRACE(" field %d [%s]\n", i+1, debugstr_a(sval)); ofs += bytes_per_strref; } else @@ -2310,12 +2235,12 @@ static void dump_record( LibmsiRecord *rec ) n = libmsi_record_get_field_count( rec ); for( i=1; i<=n; i++ ) { - const WCHAR *sval; + const char *sval; if( libmsi_record_is_null( rec, i ) ) TRACE("row -> []\n"); else if( (sval = _libmsi_record_get_string_raw( rec, i )) ) - TRACE("row -> [%s]\n", debugstr_w(sval)); + TRACE("row -> [%s]\n", debugstr_a(sval)); else TRACE("row -> [0x%08x]\n", libmsi_record_get_integer( rec, i ) ); } @@ -2323,19 +2248,19 @@ static void dump_record( LibmsiRecord *rec ) static void dump_table( const string_table *st, const uint16_t *rawdata, unsigned rawsize ) { - const WCHAR *sval; + const char *sval; unsigned i; for( i=0; i<(rawsize/2); i++ ) { sval = msi_string_lookup_id( st, rawdata[i] ); - TRACE(" %04x %s\n", rawdata[i], debugstr_w(sval) ); + TRACE(" %04x %s\n", rawdata[i], debugstr_a(sval) ); } } static unsigned* msi_record_to_row( const LibmsiTableView *tv, LibmsiRecord *rec ) { - const WCHAR *str; + const char *str; unsigned i, r, *data; data = msi_alloc( tv->num_cols *sizeof (unsigned) ); @@ -2353,7 +2278,7 @@ static unsigned* msi_record_to_row( const LibmsiTableView *tv, LibmsiRecord *rec str = _libmsi_record_get_string_raw( rec, i+1 ); if (str) { - r = _libmsi_id_from_stringW( tv->db->strings, str, &data[i] ); + r = _libmsi_id_from_string_utf8( tv->db->strings, str, &data[i] ); /* if there's no matching string in the string table, these keys can't match any record, so fail now. */ @@ -2432,10 +2357,10 @@ static unsigned msi_table_find_row( LibmsiTableView *tv, LibmsiRecord *rec, unsi typedef struct { struct list entry; - WCHAR *name; + char *name; } TRANSFORMDATA; -static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, +static unsigned msi_table_load_transform( LibmsiDatabase *db, GsfInfile *stg, string_table *st, TRANSFORMDATA *transform, unsigned bytes_per_strref ) { @@ -2443,8 +2368,8 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, LibmsiTableView *tv = NULL; unsigned r, n, sz, i, mask, num_cols, colcol = 0, rawsize = 0; LibmsiRecord *rec = NULL; - WCHAR coltable[32]; - const WCHAR *name; + char coltable[32]; + const char *name; if (!transform) return LIBMSI_RESULT_SUCCESS; @@ -2452,13 +2377,13 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, name = transform->name; coltable[0] = 0; - TRACE("%p %p %p %s\n", db, stg, st, debugstr_w(name) ); + TRACE("%p %p %p %s\n", db, stg, st, debugstr_a(name) ); /* read the transform data */ read_stream_data( stg, name, &rawdata, &rawsize ); if ( !rawdata ) { - TRACE("table %s empty\n", debugstr_w(name) ); + TRACE("table %s empty\n", debugstr_a(name) ); return LIBMSI_RESULT_INVALID_TABLE; } @@ -2472,7 +2397,7 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, goto err; TRACE("name = %s columns = %u row_size = %u raw size = %u\n", - debugstr_w(name), tv->num_cols, tv->row_size, rawsize ); + debugstr_a(name), tv->num_cols, tv->row_size, rawsize ); /* interpret the data */ for (n = 0; n < rawsize;) @@ -2531,14 +2456,14 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, rec = msi_get_transform_record( tv, st, stg, &rawdata[n], bytes_per_strref ); if (rec) { - WCHAR table[32]; + char table[32]; unsigned sz = 32; unsigned number = MSI_NULL_INTEGER; unsigned row = 0; - if (!strcmpW( name, szColumns )) + if (!strcmp( name, szColumns )) { - _libmsi_record_get_stringW( rec, 1, table, &sz ); + _libmsi_record_get_string( rec, 1, table, &sz ); number = libmsi_record_get_integer( rec, 2 ); /* @@ -2548,10 +2473,10 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, if ( number == MSI_NULL_INTEGER ) { /* reset the column number on a new table */ - if (strcmpW( coltable, table )) + if (strcmp( coltable, table )) { colcol = 0; - strcpyW( coltable, table ); + strcpy( coltable, table ); } /* fix nul column numbers */ @@ -2594,7 +2519,7 @@ static unsigned msi_table_load_transform( LibmsiDatabase *db, IStorage *stg, WARN("failed to insert row %u\n", r); } - if (number != MSI_NULL_INTEGER && !strcmpW( name, szColumns )) + if (number != MSI_NULL_INTEGER && !strcmp( name, szColumns )) msi_update_table_columns( db, table ); g_object_unref(rec); @@ -2617,14 +2542,12 @@ err: * * Enumerate the table transforms in a transform storage and apply each one. */ -unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ) +unsigned msi_table_apply_transform( LibmsiDatabase *db, GsfInfile *stg ) { struct list transforms; - IEnumSTATSTG *stgenum = NULL; TRANSFORMDATA *transform; TRANSFORMDATA *tables = NULL, *columns = NULL; - HRESULT r; - STATSTG stat; + unsigned i, n, r; string_table *strings; unsigned ret = LIBMSI_RESULT_FUNCTION_FAILED; unsigned bytes_per_strref; @@ -2635,29 +2558,23 @@ unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ) if( !strings ) goto end; - r = IStorage_EnumElements( stg, 0, NULL, 0, &stgenum ); - if( FAILED( r ) ) - goto end; + n = gsf_infile_num_children(stg); list_init(&transforms); - while ( true ) + for (i = 0; i < n; i++) { LibmsiTableView *tv = NULL; - WCHAR name[0x40]; - unsigned count = 0; - - r = IEnumSTATSTG_Next( stgenum, 1, &stat, &count ); - if ( FAILED( r ) || !count ) - break; + const uint8_t *encname; + char name[0x40]; - decode_streamname( stat.pwcsName, name ); - CoTaskMemFree( stat.pwcsName ); - if ( name[0] != 0x4840 ) + encname = (const uint8_t *) gsf_infile_name_by_index(stg, i); + if ( encname[0] != 0xe4 || encname[1] != 0xa1 || encname[2] != 0x80) continue; - if ( !strcmpW( name+1, szStringPool ) || - !strcmpW( name+1, szStringData ) ) + decode_streamname( encname, name ); + if ( !strcmp( name+3, szStringPool ) || + !strcmp( name+3, szStringData ) ) continue; transform = msi_alloc_zero( sizeof(TRANSFORMDATA) ); @@ -2666,14 +2583,14 @@ unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ) list_add_tail( &transforms, &transform->entry ); - transform->name = strdupW( name + 1 ); + transform->name = strdup( name + 1 ); - if ( !strcmpW( transform->name, szTables ) ) + if ( !strcmp( transform->name, szTables ) ) tables = transform; - else if (!strcmpW( transform->name, szColumns ) ) + else if (!strcmp( transform->name, szColumns ) ) columns = transform; - TRACE("transform contains stream %s\n", debugstr_w(name)); + TRACE("transform contains stream %s\n", debugstr_a(name)); /* load the table */ r = table_view_create( db, transform->name, (LibmsiView**) &tv ); @@ -2708,8 +2625,8 @@ unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ) { transform = LIST_ENTRY( list_head( &transforms ), TRANSFORMDATA, entry ); - if ( strcmpW( transform->name, szColumns ) && - strcmpW( transform->name, szTables ) && + if ( strcmp( transform->name, szColumns ) && + strcmp( transform->name, szTables ) && ret == LIBMSI_RESULT_SUCCESS ) { ret = msi_table_load_transform( db, stg, strings, transform, bytes_per_strref ); @@ -2724,8 +2641,6 @@ unsigned msi_table_apply_transform( LibmsiDatabase *db, IStorage *stg ) append_storage_to_db( db, stg ); end: - if ( stgenum ) - IEnumSTATSTG_Release( stgenum ); if ( strings ) msi_destroy_stringtable( strings ); diff --git a/libmsi/tokenize.c b/libmsi/tokenize.c index 007411e..3d95854 100644 --- a/libmsi/tokenize.c +++ b/libmsi/tokenize.c @@ -20,9 +20,6 @@ #include <stdarg.h> #include <stdlib.h> -#include "windef.h" -#include "winbase.h" -#include "unicode.h" #include "query.h" #include "sql-parser.h" @@ -88,7 +85,7 @@ static const Keyword aKeywordTable[] = { ** Comparison function for binary search. */ static int sql_compare_keyword(const void *m1, const void *m2){ - const WCHAR *p = m1; + const char *p = m1; const Keyword *k = m2; const char *q = k->zName; @@ -111,14 +108,14 @@ static int sql_compare_keyword(const void *m1, const void *m2){ ** keyword. If it is a keyword, the token code of that keyword is ** returned. If the input is not a keyword, TK_ID is returned. */ -static int sqlite_find_keyword(const WCHAR *z, int n){ - WCHAR str[MAX_TOKEN_LEN+1]; +static int sqlite_find_keyword(const char *z, int n){ + char str[MAX_TOKEN_LEN+1]; Keyword *r; if( n>MAX_TOKEN_LEN ) return TK_ID; - memcpy( str, z, n*sizeof (WCHAR) ); + memcpy( str, z, n*sizeof (char) ); str[n] = 0; r = bsearch( str, aKeywordTable, KEYWORD_COUNT, sizeof (Keyword), sql_compare_keyword ); if( r ) @@ -163,7 +160,7 @@ static const char isIdChar[] = { ** -1 if the token is (or might be) incomplete. Store the token ** type in *tokenType before returning. */ -int sql_get_token(const WCHAR *z, int *tokenType, int *skip){ +int sql_get_token(const char *z, int *tokenType, int *skip){ int i; *skip = 0; diff --git a/libmsi/unicode.h b/libmsi/unicode.h deleted file mode 100644 index d134f3e..0000000 --- a/libmsi/unicode.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Wine internal Unicode definitions - * - * Copyright 2000 Alexandre Julliard - * - * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - */ - -#ifndef __WINE_WINE_UNICODE_H -#define __WINE_WINE_UNICODE_H - -#include <stdarg.h> - -#include <windef.h> -#include <winbase.h> -#include <winnls.h> - -#ifdef __cplusplus -extern "C" { -#endif - -extern long int strtolW( const WCHAR *nptr, WCHAR **endptr, int base ); -extern int sprintfW( WCHAR *str, const WCHAR *format, ... ); -extern int snprintfW( WCHAR *str, size_t len, const WCHAR *format, ... ); -extern int vsprintfW( WCHAR *str, const WCHAR *format, va_list valist ); -extern int vsnprintfW( WCHAR *str, size_t len, const WCHAR *format, va_list valist ); - -/* some useful string manipulation routines */ - -static inline unsigned int strlenW( const WCHAR *str ) -{ - const WCHAR *s = str; - while (*s) s++; - return s - str; -} - -static inline WCHAR *strcpyW( WCHAR *dst, const WCHAR *src ) -{ - WCHAR *p = dst; - while ((*p++ = *src++)); - return dst; -} - -/* strncpy doesn't do what you think, don't use it */ -#define strncpyW(d,s,n) error do_not_use_strncpyW_use_lstrcpynW_or_memcpy_instead - -static inline WCHAR *strcpynW( WCHAR *dst, const WCHAR *src, unsigned count ) -{ - WCHAR *d = dst; - const WCHAR *s = src; - - while ((count > 1) && *s) - { - count--; - *d++ = *s++; - } - if (count) *d = 0; - return dst; -} - -static inline int strcmpW( const WCHAR *str1, const WCHAR *str2 ) -{ - while (*str1 && (*str1 == *str2)) { str1++; str2++; } - return *str1 - *str2; -} - -static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n ) -{ - if (n <= 0) return 0; - while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; } - return *str1 - *str2; -} - -static inline WCHAR *strcatW( WCHAR *dst, const WCHAR *src ) -{ - strcpyW( dst + strlenW(dst), src ); - return dst; -} - -static inline WCHAR *strchrW( const WCHAR *str, WCHAR ch ) -{ - do { if (*str == ch) return (WCHAR *)(uintptr_t)str; } while (*str++); - return NULL; -} - -static inline WCHAR *strrchrW( const WCHAR *str, WCHAR ch ) -{ - WCHAR *ret = NULL; - do { if (*str == ch) ret = (WCHAR *)(uintptr_t)str; } while (*str++); - return ret; -} - -static inline WCHAR *strpbrkW( const WCHAR *str, const WCHAR *accept ) -{ - for ( ; *str; str++) if (strchrW( accept, *str )) return (WCHAR *)(uintptr_t)str; - return NULL; -} - -static inline size_t strspnW( const WCHAR *str, const WCHAR *accept ) -{ - const WCHAR *ptr; - for (ptr = str; *ptr; ptr++) if (!strchrW( accept, *ptr )) break; - return ptr - str; -} - -static inline size_t strcspnW( const WCHAR *str, const WCHAR *reject ) -{ - const WCHAR *ptr; - for (ptr = str; *ptr; ptr++) if (strchrW( reject, *ptr )) break; - return ptr - str; -} - -static inline WCHAR *memchrW( const WCHAR *ptr, WCHAR ch, size_t n ) -{ - const WCHAR *end; - for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) return (WCHAR *)(uintptr_t)ptr; - return NULL; -} - -static inline WCHAR *memrchrW( const WCHAR *ptr, WCHAR ch, size_t n ) -{ - const WCHAR *end; - WCHAR *ret = NULL; - for (end = ptr + n; ptr < end; ptr++) if (*ptr == ch) ret = (WCHAR *)(uintptr_t)ptr; - return ret; -} - -static inline long int atolW( const WCHAR *str ) -{ - return strtolW( str, (WCHAR **)0, 10 ); -} - -static inline int atoiW( const WCHAR *str ) -{ - return (int)atolW( str ); -} - -#ifdef __cplusplus -} -#endif - -#endif /* __WINE_WINE_UNICODE_H */ diff --git a/libmsi/update.c b/libmsi/update.c index 47b7caf..95effb4 100644 --- a/libmsi/update.c +++ b/libmsi/update.c @@ -20,15 +20,9 @@ #include <stdarg.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -152,8 +146,8 @@ static unsigned update_view_get_dimensions( LibmsiView *view, unsigned *rows, un return wv->ops->get_dimensions( wv, rows, cols ); } -static unsigned update_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned update_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiUpdateView *uv = (LibmsiUpdateView*)view; LibmsiView *wv; @@ -212,7 +206,7 @@ static const LibmsiViewOps update_ops = NULL, }; -unsigned update_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *table, +unsigned update_view_create( LibmsiDatabase *db, LibmsiView **view, char *table, column_info *columns, struct expr *expr ) { LibmsiUpdateView *uv = NULL; diff --git a/libmsi/utf16/snprintfW.c b/libmsi/utf16/snprintfW.c deleted file mode 100644 index 3e3ee05..0000000 --- a/libmsi/utf16/snprintfW.c +++ /dev/null @@ -1,38 +0,0 @@ -/* Formatted output to strings. - Copyright (C) 1999, 2002, 2005-2007, 2009-2012 Free Software Foundation, - Inc. - - This program 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 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - 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, see <http://www.gnu.org/licenses/>. */ - -#include "unicode.h" -#include <stdarg.h> -#include <stdlib.h> - -int -snprintfW (WCHAR *buf, size_t size, const WCHAR *format, ...) -{ - va_list args; - int result; - - va_start (args, format); - result = vsnprintfW (buf, size, format, args); - va_end (args); - return result; -} - -int -vsnprintfW (WCHAR *buf, size_t size, const WCHAR *format, va_list args) -{ - return _vsnwprintf (buf, size, format, args); -} diff --git a/libmsi/utf16/sprintfW.c b/libmsi/utf16/sprintfW.c deleted file mode 100644 index ebb8909..0000000 --- a/libmsi/utf16/sprintfW.c +++ /dev/null @@ -1,38 +0,0 @@ -/* Formatted output to strings. - Copyright (C) 1999, 2002, 2005-2007, 2009-2012 Free Software Foundation, - Inc. - - This program 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 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - 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, see <http://www.gnu.org/licenses/>. */ - -#include "unicode.h" -#include <stdarg.h> -#include <limits.h> - -int -sprintfW (WCHAR *buf, const WCHAR *format, ...) -{ - va_list args; - int result; - - va_start (args, format); - result = vsprintfW (buf, format, args); - va_end (args); - return result; -} - -int -vsprintfW (WCHAR *buf, const WCHAR *format, va_list args) -{ - return _vsnwprintf (buf, INT_MAX, format, args); -} diff --git a/libmsi/utf16/strtolW.c b/libmsi/utf16/strtolW.c deleted file mode 100644 index 5c2a818..0000000 --- a/libmsi/utf16/strtolW.c +++ /dev/null @@ -1,176 +0,0 @@ -/* Convert string representation of a number into an integer value. - - Copyright (C) 1991-1992, 1994-1999, 2003, 2005-2007, 2009-2012 Free Software - Foundation, Inc. - - NOTE: The canonical source of this file is maintained with the GNU C - Library. Bugs can be reported to bug-glibc@gnu.org. - - This program is free software: you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by the - Free Software Foundation; either version 3 of the License, or any - later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. */ - -#ifdef _LIBC -# define USE_NUMBER_GROUPING -#else -# include <config.h> -#endif - -#include "unicode.h" -#include <errno.h> -#ifndef __set_errno -# define __set_errno(Val) errno = (Val) -#endif - -#include <limits.h> -#include <stddef.h> -#include <stdlib.h> -#include <string.h> - -/* Convert NPTR to an 'unsigned long int' or 'long int' in base BASE. - If BASE is 0 the base is determined by the presence of a leading - zero, indicating octal or a leading "0x" or "0X", indicating hexadecimal. - If BASE is < 2 or > 36, it is reset to 10. - If ENDPTR is not NULL, a pointer to the character after the last - one converted is stored in *ENDPTR. */ - -long -strtolW (const WCHAR *nptr, WCHAR **endptr, int base) -{ - int negative; - unsigned long cutoff; - unsigned int cutlim; - unsigned long i; - const WCHAR *s; - UCHAR c; - const WCHAR *save, *end; - int overflow; - - if (base < 0 || base == 1 || base > 36) - { - __set_errno (EINVAL); - return 0; - } - - save = s = nptr; - - /* Skip white space. */ - while (*s == ' ' || *s == '\n' ) - ++s; - if (*s == '\0') - goto noconv; - - /* Check for a sign. */ - if (*s == '-') - { - negative = 1; - ++s; - } - else if (*s == '+') - { - negative = 0; - ++s; - } - else - negative = 0; - - /* Recognize number prefix and if BASE is zero, figure it out ourselves. */ - if (*s == '0') - { - if ((base == 0 || base == 16) && (s[1] == 'X' || s[1] == 'x')) - { - s += 2; - base = 16; - } - else if (base == 0) - base = 8; - } - else if (base == 0) - base = 10; - - /* Save the pointer so we can check later if anything happened. */ - save = s; - - end = NULL; - - cutoff = ULONG_MAX / (unsigned long) base; - cutlim = ULONG_MAX % (unsigned long) base; - - overflow = 0; - i = 0; - for (c = *s; c; c = *++s) - { - if (s == end) - break; - if (c >= '0' && c <= '9') - c -= '0'; - else if (c >= 'A' && c <= 'Z') - c = c - 'A' + 10; - else if (c >= 'a' && c <= 'z') - c = c - 'a' + 10; - else - break; - if ((int) c >= base) - break; - /* Check for overflow. */ - if (i > cutoff || (i == cutoff && c > cutlim)) - overflow = 1; - else - { - i *= (unsigned long) base; - i += c; - } - } - - /* Check if anything actually happened. */ - if (s == save) - goto noconv; - - /* Store in ENDPTR the address of one character - past the last character we converted. */ - if (endptr != NULL) - *endptr = (WCHAR *) s; - - /* Check for a value that is within the range of - 'unsigned long', but outside the range of 'long'. */ - if (overflow == 0 - && i > (negative - ? -((unsigned long int) (LONG_MIN + 1)) + 1 - : (unsigned long int) LONG_MAX)) - overflow = 1; - - if (overflow) - { - __set_errno (ERANGE); - return ULONG_MAX; - } - - /* Return the result of the appropriate sign. */ - return negative ? -i : i; - -noconv: - /* We must handle a special case here: the base is 0 or 16 and the - first two characters are '0' and 'x', but the rest are no - hexadecimal digits. This is no error case. We return 0 and - ENDPTR points to the 'x'. */ - if (endptr != NULL) - { - if (save - nptr >= 2 && (save[-1] == 'X' || save[-1] == 'x') - && save[-2] == '0') - *endptr = (WCHAR *) &save[-1]; - else - /* There was no number to convert. */ - *endptr = (WCHAR *) nptr; - } - - return 0L; -} diff --git a/libmsi/where.c b/libmsi/where.c index b7b5ff0..18473ec 100644 --- a/libmsi/where.c +++ b/libmsi/where.c @@ -22,16 +22,9 @@ #include <stdarg.h> #include <assert.h> -#include "windef.h" -#include "winbase.h" -#include "winerror.h" #include "debug.h" -#include "unicode.h" #include "libmsi.h" -#include "objbase.h" -#include "objidl.h" #include "msipriv.h" -#include "winnls.h" #include "query.h" @@ -139,7 +132,7 @@ static unsigned add_row(LibmsiWhereView *wv, unsigned vals[]) wv->reorder_size = newsize; } - new = msi_alloc(FIELD_OFFSET( LibmsiRowEntry, values[wv->table_count] )); + new = msi_alloc(offsetof( LibmsiRowEntry, values[wv->table_count] )); if (!new) return LIBMSI_RESULT_OUTOFMEMORY; @@ -178,7 +171,7 @@ static unsigned parse_column(LibmsiWhereView *wv, union ext_column *column, do { - const WCHAR *table_name; + const char *table_name; if (column->unparsed.table) { @@ -186,20 +179,20 @@ static unsigned parse_column(LibmsiWhereView *wv, union ext_column *column, NULL, &table_name); if (r != LIBMSI_RESULT_SUCCESS) return r; - if (strcmpW(table_name, column->unparsed.table) != 0) + if (strcmp(table_name, column->unparsed.table) != 0) continue; } for(i = 1; i <= table->col_count; i++) { - const WCHAR *col_name; + const char *col_name; r = table->view->ops->get_column_info(table->view, i, &col_name, column_type, NULL, NULL); if(r != LIBMSI_RESULT_SUCCESS ) return r; - if(strcmpW(col_name, column->unparsed.column)) + if(strcmp(col_name, column->unparsed.column)) continue; column->parsed.column = i; column->parsed.table = table; @@ -208,7 +201,7 @@ static unsigned parse_column(LibmsiWhereView *wv, union ext_column *column, } while ((table = table->next)); - WARN("Couldn't find column %s.%s\n", debugstr_w( column->unparsed.table ), debugstr_w( column->unparsed.column ) ); + WARN("Couldn't find column %s.%s\n", debugstr_a( column->unparsed.table ), debugstr_a( column->unparsed.column ) ); return LIBMSI_RESULT_BAD_QUERY_SYNTAX; } @@ -235,7 +228,7 @@ static unsigned where_view_fetch_int( LibmsiView *view, unsigned row, unsigned c return table->view->ops->fetch_int(table->view, rows[table->table_index], col, val); } -static unsigned where_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, IStream **stm ) +static unsigned where_view_fetch_stream( LibmsiView *view, unsigned row, unsigned col, GsfInput **stm ) { LibmsiWhereView *wv = (LibmsiWhereView*)view; JOINTABLE *table; @@ -484,7 +477,7 @@ static unsigned expr_eval_unary( LibmsiWhereView *wv, const unsigned rows[], static unsigned expr_eval_string( LibmsiWhereView *wv, const unsigned rows[], const struct expr *expr, const LibmsiRecord *record, - const WCHAR **str ) + const char **str ) { unsigned val = 0, r = LIBMSI_RESULT_SUCCESS; @@ -519,7 +512,7 @@ static unsigned expr_eval_strcmp( LibmsiWhereView *wv, const unsigned rows[], co int *val, const LibmsiRecord *record ) { int sr; - const WCHAR *l_str, *r_str; + const char *l_str, *r_str; unsigned r; *val = true; @@ -538,7 +531,7 @@ static unsigned expr_eval_strcmp( LibmsiWhereView *wv, const unsigned rows[], co else if( r_str && ! l_str ) sr = -1; else - sr = strcmpW( l_str, r_str ); + sr = strcmp( l_str, r_str ); *val = ( expr->op == OP_EQ && ( sr == 0 ) ) || ( expr->op == OP_NE && ( sr != 0 ) ); @@ -857,8 +850,8 @@ static unsigned where_view_get_dimensions( LibmsiView *view, unsigned *rows, uns return LIBMSI_RESULT_SUCCESS; } -static unsigned where_view_get_column_info( LibmsiView *view, unsigned n, const WCHAR **name, - unsigned *type, bool *temporary, const WCHAR **table_name ) +static unsigned where_view_get_column_info( LibmsiView *view, unsigned n, const char **name, + unsigned *type, bool *temporary, const char **table_name ) { LibmsiWhereView *wv = (LibmsiWhereView*)view; JOINTABLE *table; @@ -921,7 +914,7 @@ static unsigned where_view_find_matching_rows( LibmsiView *view, unsigned col, if (col == 0 || col > wv->col_count) return LIBMSI_RESULT_INVALID_PARAMETER; - for (i = PtrToUlong(*handle); i < wv->row_count; i++) + for (i = (uintptr_t)*handle; i < wv->row_count; i++) { if (view->ops->fetch_int( view, i, col, &row_value ) != LIBMSI_RESULT_SUCCESS) continue; @@ -929,7 +922,7 @@ static unsigned where_view_find_matching_rows( LibmsiView *view, unsigned col, if (row_value == val) { *row = i; - *handle = UlongToPtr(i + 1); + *handle = (MSIITERHANDLE)(uintptr_t)(i + 1); return LIBMSI_RESULT_SUCCESS; } } @@ -1097,14 +1090,14 @@ static unsigned where_view_verify_condition( LibmsiWhereView *wv, struct expr *c return LIBMSI_RESULT_SUCCESS; } -unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *tables, +unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, char *tables, struct expr *cond ) { LibmsiWhereView *wv = NULL; unsigned r, valid = 0; - WCHAR *ptr; + char *ptr; - TRACE("(%s)\n", debugstr_w(tables) ); + TRACE("(%s)\n", debugstr_a(tables) ); wv = msi_alloc_zero( sizeof *wv ); if( !wv ) @@ -1119,7 +1112,7 @@ unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *tables { JOINTABLE *table; - if ((ptr = strchrW(tables, ' '))) + if ((ptr = strchr(tables, ' '))) *ptr = '\0'; table = msi_alloc(sizeof(JOINTABLE)); @@ -1132,7 +1125,7 @@ unsigned where_view_create( LibmsiDatabase *db, LibmsiView **view, WCHAR *tables r = table_view_create(db, tables, &table->view); if (r != LIBMSI_RESULT_SUCCESS) { - WARN("can't create table: %s\n", debugstr_w(tables)); + WARN("can't create table: %s\n", debugstr_a(tables)); msi_free(table); r = LIBMSI_RESULT_BAD_QUERY_SYNTAX; goto end; diff --git a/libmsi/winstubs/winstubs.h b/libmsi/winstubs/winstubs.h deleted file mode 100644 index 9f0f51c..0000000 --- a/libmsi/winstubs/winstubs.h +++ /dev/null @@ -1,473 +0,0 @@ -#define __WINE_PROPVARUTIL_H -#define _WINSPOOL_ -#define _WINGDI_ -#define _IMM_ -#define _INC_COMMDLG -#define __servprov_h__ -#define __urlmon_h__ -#define _INC_VIRTDISK -#define _WINIOCTL_ -#define _WINNETWK_ -#define _WINPERF_ -#define _WINREG_ -#define _NTDDSCRD_H2_ -#define _WINSOCKAPI_ -#define _WINSVC_ -#define _WINSCARD_H_ -#define _INC_CDERR -#define _DDEHEADER_INCLUDED_ -#define _INC_DDEMLH -#define _DLGSH_INCLUDED_ -#define _INC_EXCPT -#define INCLUDED_TYPES_FCI_FDI -#define __fusion_h__ -#define _LZEXPAND_ -#define _MCX_H_ -#define _INC_MMSYSTEM -#define __MSIDEFS -#define NCB_INCLUDED -#define _INC_NCRYPT -#define _INC_BCRYPT -#define SAL_HXX -#define _INC_SDKDDKVER -#define _WINCON_ -#define __WINCRYPT_H__ -#define __WINEFS_H__ -#define _MSI_H_ -#define _MSIQUERY_H_ - -typedef struct tagMSG *LPMSG; -typedef struct tagREGSAM REGSAM; - -typedef struct AsyncIAdviseSink AsyncIAdviseSink; -typedef struct AsyncIAdviseSink2 AsyncIAdviseSink2; -typedef struct AsyncIMultiQI AsyncIMultiQI; -typedef struct AsyncIPipeByte AsyncIPipeByte; -typedef struct AsyncIPipeDouble AsyncIPipeDouble; -typedef struct AsyncIPipeLong AsyncIPipeLong; -typedef struct AsyncIUnknown AsyncIUnknown; -typedef struct FolderItem FolderItem; -typedef struct FolderItemVerb FolderItemVerb; -typedef struct FolderItemVerbs FolderItemVerbs; -typedef struct FolderItems FolderItems; -typedef struct IAccessible IAccessible; -typedef struct IActiveScript IActiveScript; -typedef struct IActiveScriptError IActiveScriptError; -typedef struct IActiveScriptParse IActiveScriptParse; -typedef struct IActiveScriptParseProcedure IActiveScriptParseProcedure; -typedef struct IActiveScriptParseProcedureOld IActiveScriptParseProcedureOld; -typedef struct IActiveScriptSite IActiveScriptSite; -typedef struct IActiveScriptSiteInterruptPoll IActiveScriptSiteInterruptPoll; -typedef struct IActiveScriptSiteWindow IActiveScriptSiteWindow; -typedef struct IActiveScriptStats IActiveScriptStats; -typedef struct IAddrExclusionControl IAddrExclusionControl; -typedef struct IAddrTrackingControl IAddrTrackingControl; -typedef struct IAdviseSink IAdviseSink; -typedef struct IAdviseSink2 IAdviseSink2; -typedef struct IAdviseSinkEx IAdviseSinkEx; -typedef struct IAsyncManager IAsyncManager; -typedef struct IAsyncRpcChannelBuffer IAsyncRpcChannelBuffer; -typedef struct IAuthenticate IAuthenticate; -typedef struct IBindCtx IBindCtx; -typedef struct IBindEventHandler IBindEventHandler; -typedef struct IBindHost IBindHost; -typedef struct IBindProtocol IBindProtocol; -typedef struct IBindStatusCallback IBindStatusCallback; -typedef struct IBinding IBinding; -typedef struct IBlockingLock IBlockingLock; -typedef struct ICSSFilter ICSSFilter; -typedef struct ICSSFilterSite ICSSFilterSite; -typedef struct ICallFactory ICallFactory; -typedef struct ICancelMethodCalls ICancelMethodCalls; -typedef struct ICatInformation ICatInformation; -typedef struct ICatRegister ICatRegister; -typedef struct ICatalogFileInfo ICatalogFileInfo; -typedef struct IChannelHook IChannelHook; -typedef struct IChannelMgr IChannelMgr; -typedef struct IClassActivator IClassActivator; -typedef struct IClassFactory IClassFactory; -typedef struct IClassFactory2 IClassFactory2; -typedef struct IClientSecurity IClientSecurity; -typedef struct ICodeInstall ICodeInstall; -typedef struct IConnectionPoint IConnectionPoint; -typedef struct IConnectionPointContainer IConnectionPointContainer; -typedef struct IContinue IContinue; -typedef struct IContinueCallback IContinueCallback; -typedef struct ICreateErrorInfo ICreateErrorInfo; -typedef struct ICreateTypeInfo ICreateTypeInfo; -typedef struct ICreateTypeInfo2 ICreateTypeInfo2; -typedef struct ICreateTypeLib ICreateTypeLib; -typedef struct ICreateTypeLib2 ICreateTypeLib2; -typedef struct ICustomDoc ICustomDoc; -typedef struct IDataAdviseHolder IDataAdviseHolder; -typedef struct IDataFilter IDataFilter; -typedef struct IDataObject IDataObject; -typedef struct IDeskBand IDeskBand; -typedef struct IDirectWriterLock IDirectWriterLock; -typedef struct IDispError IDispError; -typedef struct IDispatch IDispatch; -typedef struct IDispatchEx IDispatchEx; -typedef struct IDocHostShowUI IDocHostShowUI; -typedef struct IDocHostUIHandler IDocHostUIHandler; -typedef struct IDockingWindow IDockingWindow; -typedef struct IDropSource IDropSource; -typedef struct IDropTarget IDropTarget; -typedef struct IDummyHICONIncluder IDummyHICONIncluder; -typedef struct IEncodingFilterFactory IEncodingFilterFactory; -typedef struct IEnumCATEGORYINFO IEnumCATEGORYINFO; -typedef struct IEnumChannels IEnumChannels; -typedef struct IEnumCodePage IEnumCodePage; -typedef struct IEnumConnectionPoints IEnumConnectionPoints; -typedef struct IEnumConnections IEnumConnections; -typedef struct IEnumFORMATETC IEnumFORMATETC; -typedef struct IEnumGUID IEnumGUID; -typedef struct IEnumHLITEM IEnumHLITEM; -typedef struct IEnumIDList IEnumIDList; -typedef struct IEnumMoniker IEnumMoniker; -typedef struct IEnumOLEVERB IEnumOLEVERB; -typedef struct IEnumOleDocumentViews IEnumOleDocumentViews; -typedef struct IEnumOleUndoUnits IEnumOleUndoUnits; -typedef struct IEnumRfc1766 IEnumRfc1766; -typedef struct IEnumSTATDATA IEnumSTATDATA; -typedef struct IEnumSTATPROPSETSTG IEnumSTATPROPSETSTG; -typedef struct IEnumSTATPROPSTG IEnumSTATPROPSTG; -typedef struct IEnumSTATSTG IEnumSTATSTG; -typedef struct IEnumSTATURL IEnumSTATURL; -typedef struct IEnumString IEnumString; -typedef struct IEnumUnknown IEnumUnknown; -typedef struct IEnumVARIANT IEnumVARIANT; -typedef struct IErrorInfo IErrorInfo; -typedef struct IErrorLog IErrorLog; -typedef struct IExtensionServices IExtensionServices; -typedef struct IExternalConnection IExternalConnection; -typedef struct IFillLockBytes IFillLockBytes; -typedef struct IFilter IFilter; -typedef struct IFolderViewOC IFolderViewOC; -typedef struct IFont IFont; -typedef struct IFontDisp IFontDisp; -typedef struct IFontEventsDisp IFontEventsDisp; -typedef struct IForegroundTransfer IForegroundTransfer; -typedef struct IGlobalInterfaceTable IGlobalInterfaceTable; -typedef struct IHTMLAnchorElement IHTMLAnchorElement; -typedef struct IHTMLAreaElement IHTMLAreaElement; -typedef struct IHTMLAreasCollection IHTMLAreasCollection; -typedef struct IHTMLBGsound IHTMLBGsound; -typedef struct IHTMLBRElement IHTMLBRElement; -typedef struct IHTMLBaseElement IHTMLBaseElement; -typedef struct IHTMLBaseFontElement IHTMLBaseFontElement; -typedef struct IHTMLBlockElement IHTMLBlockElement; -typedef struct IHTMLBodyElement IHTMLBodyElement; -typedef struct IHTMLButtonElement IHTMLButtonElement; -typedef struct IHTMLCommentElement IHTMLCommentElement; -typedef struct IHTMLControlElement IHTMLControlElement; -typedef struct IHTMLControlRange IHTMLControlRange; -typedef struct IHTMLDDElement IHTMLDDElement; -typedef struct IHTMLDListElement IHTMLDListElement; -typedef struct IHTMLDTElement IHTMLDTElement; -typedef struct IHTMLDatabinding IHTMLDatabinding; -typedef struct IHTMLDialog IHTMLDialog; -typedef struct IHTMLDivElement IHTMLDivElement; -typedef struct IHTMLDivPosition IHTMLDivPosition; -typedef struct IHTMLDocument IHTMLDocument; -typedef struct IHTMLDocument2 IHTMLDocument2; -typedef struct IHTMLElement IHTMLElement; -typedef struct IHTMLElementCollection IHTMLElementCollection; -typedef struct IHTMLEmbedElement IHTMLEmbedElement; -typedef struct IHTMLEventObj IHTMLEventObj; -typedef struct IHTMLFieldSetElement IHTMLFieldSetElement; -typedef struct IHTMLFiltersCollection IHTMLFiltersCollection; -typedef struct IHTMLFontElement IHTMLFontElement; -typedef struct IHTMLFontNamesCollection IHTMLFontNamesCollection; -typedef struct IHTMLFontSizesCollection IHTMLFontSizesCollection; -typedef struct IHTMLFormElement IHTMLFormElement; -typedef struct IHTMLFrameBase IHTMLFrameBase; -typedef struct IHTMLFrameElement IHTMLFrameElement; -typedef struct IHTMLFrameSetElement IHTMLFrameSetElement; -typedef struct IHTMLFramesCollection2 IHTMLFramesCollection2; -typedef struct IHTMLHRElement IHTMLHRElement; -typedef struct IHTMLHeaderElement IHTMLHeaderElement; -typedef struct IHTMLIFrameElement IHTMLIFrameElement; -typedef struct IHTMLImageElementFactory IHTMLImageElementFactory; -typedef struct IHTMLImgElement IHTMLImgElement; -typedef struct IHTMLInputButtonElement IHTMLInputButtonElement; -typedef struct IHTMLInputFileElement IHTMLInputFileElement; -typedef struct IHTMLInputHiddenElement IHTMLInputHiddenElement; -typedef struct IHTMLInputImage IHTMLInputImage; -typedef struct IHTMLInputTextElement IHTMLInputTextElement; -typedef struct IHTMLIsIndexElement IHTMLIsIndexElement; -typedef struct IHTMLLIElement IHTMLLIElement; -typedef struct IHTMLLabelElement IHTMLLabelElement; -typedef struct IHTMLLegendElement IHTMLLegendElement; -typedef struct IHTMLLinkElement IHTMLLinkElement; -typedef struct IHTMLListElement IHTMLListElement; -typedef struct IHTMLLocation IHTMLLocation; -typedef struct IHTMLMapElement IHTMLMapElement; -typedef struct IHTMLMarqueeElement IHTMLMarqueeElement; -typedef struct IHTMLMetaElement IHTMLMetaElement; -typedef struct IHTMLMimeTypesCollection IHTMLMimeTypesCollection; -typedef struct IHTMLNextIdElement IHTMLNextIdElement; -typedef struct IHTMLNoShowElement IHTMLNoShowElement; -typedef struct IHTMLOListElement IHTMLOListElement; -typedef struct IHTMLObjectElement IHTMLObjectElement; -typedef struct IHTMLOpsProfile IHTMLOpsProfile; -typedef struct IHTMLOptionButtonElement IHTMLOptionButtonElement; -typedef struct IHTMLOptionElement IHTMLOptionElement; -typedef struct IHTMLOptionElementFactory IHTMLOptionElementFactory; -typedef struct IHTMLOptionsHolder IHTMLOptionsHolder; -typedef struct IHTMLParaElement IHTMLParaElement; -typedef struct IHTMLPhraseElement IHTMLPhraseElement; -typedef struct IHTMLPluginsCollection IHTMLPluginsCollection; -typedef struct IHTMLRuleStyle IHTMLRuleStyle; -typedef struct IHTMLScreen IHTMLScreen; -typedef struct IHTMLScriptElement IHTMLScriptElement; -typedef struct IHTMLSelectElement IHTMLSelectElement; -typedef struct IHTMLSelectionObject IHTMLSelectionObject; -typedef struct IHTMLSpanElement IHTMLSpanElement; -typedef struct IHTMLSpanFlow IHTMLSpanFlow; -typedef struct IHTMLStyle IHTMLStyle; -typedef struct IHTMLStyleElement IHTMLStyleElement; -typedef struct IHTMLStyleFontFace IHTMLStyleFontFace; -typedef struct IHTMLStyleSheet IHTMLStyleSheet; -typedef struct IHTMLStyleSheetRule IHTMLStyleSheetRule; -typedef struct IHTMLStyleSheetRulesCollection IHTMLStyleSheetRulesCollection; -typedef struct IHTMLStyleSheetsCollection IHTMLStyleSheetsCollection; -typedef struct IHTMLTable IHTMLTable; -typedef struct IHTMLTableCaption IHTMLTableCaption; -typedef struct IHTMLTableCell IHTMLTableCell; -typedef struct IHTMLTableCol IHTMLTableCol; -typedef struct IHTMLTableRow IHTMLTableRow; -typedef struct IHTMLTableSection IHTMLTableSection; -typedef struct IHTMLTextAreaElement IHTMLTextAreaElement; -typedef struct IHTMLTextContainer IHTMLTextContainer; -typedef struct IHTMLTextElement IHTMLTextElement; -typedef struct IHTMLTitleElement IHTMLTitleElement; -typedef struct IHTMLTxtRange IHTMLTxtRange; -typedef struct IHTMLUListElement IHTMLUListElement; -typedef struct IHTMLUnknownElement IHTMLUnknownElement; -typedef struct IHTMLWindow2 IHTMLWindow2; -typedef struct IHlink IHlink; -typedef struct IHlinkBrowseContext IHlinkBrowseContext; -typedef struct IHlinkFrame IHlinkFrame; -typedef struct IHlinkSite IHlinkSite; -typedef struct IHlinkTarget IHlinkTarget; -typedef struct IHttpNegotiate IHttpNegotiate; -typedef struct IHttpNegotiate2 IHttpNegotiate2; -typedef struct IHttpSecurity IHttpSecurity; -typedef struct IImageDecodeEventSink IImageDecodeEventSink; -typedef struct IImageDecodeFilter IImageDecodeFilter; -typedef struct IInternalUnknown IInternalUnknown; -typedef struct IInternet IInternet; -typedef struct IInternetBindInfo IInternetBindInfo; -typedef struct IInternetHostSecurityManager IInternetHostSecurityManager; -typedef struct IInternetPriority IInternetPriority; -typedef struct IInternetProtocol IInternetProtocol; -typedef struct IInternetProtocolInfo IInternetProtocolInfo; -typedef struct IInternetProtocolRoot IInternetProtocolRoot; -typedef struct IInternetProtocolSink IInternetProtocolSink; -typedef struct IInternetProtocolSinkStackable IInternetProtocolSinkStackable; -typedef struct IInternetSecurityManager IInternetSecurityManager; -typedef struct IInternetSecurityMgrSite IInternetSecurityMgrSite; -typedef struct IInternetSession IInternetSession; -typedef struct IInternetThreadSwitch IInternetThreadSwitch; -typedef struct IInternetZoneManager IInternetZoneManager; -typedef struct ILayoutStorage ILayoutStorage; -typedef struct ILockBytes ILockBytes; -typedef struct IMLangCodePages IMLangCodePages; -typedef struct IMLangConvertCharset IMLangConvertCharset; -typedef struct IMLangFontLink IMLangFontLink; -typedef struct IMLangLineBreakConsole IMLangLineBreakConsole; -typedef struct IMLangString IMLangString; -typedef struct IMLangStringAStr IMLangStringAStr; -typedef struct IMLangStringBufA IMLangStringBufA; -typedef struct IMLangStringBufW IMLangStringBufW; -typedef struct IMLangStringWStr IMLangStringWStr; -typedef struct IMalloc IMalloc; -typedef struct IMallocSpy IMallocSpy; -typedef struct IMapMIMEToCLSID IMapMIMEToCLSID; -typedef struct IMarshal IMarshal; -typedef struct IMarshal2 IMarshal2; -typedef struct IMessageFilter IMessageFilter; -typedef struct IMimeInfo IMimeInfo; -typedef struct IMoniker IMoniker; -typedef struct IMonikerProp IMonikerProp; -typedef struct IMultiLanguage IMultiLanguage; -typedef struct IMultiQI IMultiQI; -typedef struct IObjectIdentity IObjectIdentity; -typedef struct IObjectSafety IObjectSafety; -typedef struct IObjectWithSite IObjectWithSite; -typedef struct IOleAdviseHolder IOleAdviseHolder; -typedef struct IOleCache IOleCache; -typedef struct IOleCache2 IOleCache2; -typedef struct IOleCacheControl IOleCacheControl; -typedef struct IOleClientSite IOleClientSite; -typedef struct IOleCommandTarget IOleCommandTarget; -typedef struct IOleContainer IOleContainer; -typedef struct IOleControl IOleControl; -typedef struct IOleControlSite IOleControlSite; -typedef struct IOleDocument IOleDocument; -typedef struct IOleDocumentSite IOleDocumentSite; -typedef struct IOleDocumentView IOleDocumentView; -typedef struct IOleInPlaceActiveObject IOleInPlaceActiveObject; -typedef struct IOleInPlaceFrame IOleInPlaceFrame; -typedef struct IOleInPlaceObject IOleInPlaceObject; -typedef struct IOleInPlaceObjectWindowless IOleInPlaceObjectWindowless; -typedef struct IOleInPlaceSite IOleInPlaceSite; -typedef struct IOleInPlaceSiteEx IOleInPlaceSiteEx; -typedef struct IOleInPlaceSiteWindowless IOleInPlaceSiteWindowless; -typedef struct IOleInPlaceUIWindow IOleInPlaceUIWindow; -typedef struct IOleItemContainer IOleItemContainer; -typedef struct IOleLink IOleLink; -typedef struct IOleObject IOleObject; -typedef struct IOleParentUndoUnit IOleParentUndoUnit; -typedef struct IOleUndoManager IOleUndoManager; -typedef struct IOleUndoUnit IOleUndoUnit; -typedef struct IOleWindow IOleWindow; -typedef struct IOmHistory IOmHistory; -typedef struct IOmNavigator IOmNavigator; -typedef struct IOplockStorage IOplockStorage; -typedef struct IPSFactoryBuffer IPSFactoryBuffer; -typedef struct IParseDisplayName IParseDisplayName; -typedef struct IPerPropertyBrowsing IPerPropertyBrowsing; -typedef struct IPersist IPersist; -typedef struct IPersistFile IPersistFile; -typedef struct IPersistFolder IPersistFolder; -typedef struct IPersistFolder2 IPersistFolder2; -typedef struct IPersistHistory IPersistHistory; -typedef struct IPersistMemory IPersistMemory; -typedef struct IPersistMoniker IPersistMoniker; -typedef struct IPersistPropertyBag IPersistPropertyBag; -typedef struct IPersistPropertyBag2 IPersistPropertyBag2; -typedef struct IPersistStorage IPersistStorage; -typedef struct IPersistStream IPersistStream; -typedef struct IPersistStreamInit IPersistStreamInit; -typedef struct IPicture IPicture; -typedef struct IPictureDisp IPictureDisp; -typedef struct IPipeByte IPipeByte; -typedef struct IPipeDouble IPipeDouble; -typedef struct IPipeLong IPipeLong; -typedef struct IPointerInactive IPointerInactive; -typedef struct IPrint IPrint; -typedef struct IProgressNotify IProgressNotify; -typedef struct IPropertyBag IPropertyBag; -typedef struct IPropertyBag2 IPropertyBag2; -typedef struct IPropertyNotifySink IPropertyNotifySink; -typedef struct IPropertyPage IPropertyPage; -typedef struct IPropertyPage2 IPropertyPage2; -typedef struct IPropertyPageSite IPropertyPageSite; -typedef struct IPropertySetStorage IPropertySetStorage; -typedef struct IPropertyStorage IPropertyStorage; -typedef struct IProvideClassInfo IProvideClassInfo; -typedef struct IProvideClassInfo2 IProvideClassInfo2; -typedef struct IProvideMultipleClassInfo IProvideMultipleClassInfo; -typedef struct IQuickActivate IQuickActivate; -typedef struct IROTData IROTData; -typedef struct IRecordInfo IRecordInfo; -typedef struct IReleaseMarshalBuffers IReleaseMarshalBuffers; -typedef struct IRootStorage IRootStorage; -typedef struct IRpcChannelBuffer IRpcChannelBuffer; -typedef struct IRpcChannelBuffer2 IRpcChannelBuffer2; -typedef struct IRpcChannelBuffer3 IRpcChannelBuffer3; -typedef struct IRpcHelper IRpcHelper; -typedef struct IRpcOptions IRpcOptions; -typedef struct IRpcProxyBuffer IRpcProxyBuffer; -typedef struct IRpcStubBuffer IRpcStubBuffer; -typedef struct IRpcSyntaxNegotiate IRpcSyntaxNegotiate; -typedef struct IRunnableObject IRunnableObject; -typedef struct IRunningObjectTable IRunningObjectTable; -typedef struct ISequentialStream ISequentialStream; -typedef struct IServerSecurity IServerSecurity; -typedef struct IServiceProvider IServiceProvider; -typedef struct IShellBrowser IShellBrowser; -typedef struct IShellDispatch IShellDispatch; -typedef struct IShellExtInit IShellExtInit; -typedef struct IShellFolder IShellFolder; -typedef struct IShellFolderViewDual IShellFolderViewDual; -typedef struct IShellLinkA IShellLinkA; -typedef struct IShellLinkDual IShellLinkDual; -typedef struct IShellLinkW IShellLinkW; -typedef struct IShellPropSheetExt IShellPropSheetExt; -typedef struct IShellUIHelper IShellUIHelper; -typedef struct IShellView IShellView; -typedef struct IShellView2 IShellView2; -typedef struct IShellWindows IShellWindows; -typedef struct ISimpleFrameSite ISimpleFrameSite; -typedef struct ISoftDistExt ISoftDistExt; -typedef struct ISpecifyPropertyPages ISpecifyPropertyPages; -typedef struct IStdMarshalInfo IStdMarshalInfo; -typedef struct IStorage IStorage; -typedef struct IStream IStream; -typedef struct ISubscriptionMgr ISubscriptionMgr; -typedef struct ISupportErrorInfo ISupportErrorInfo; -typedef struct ISurrogate ISurrogate; -typedef struct ISynchronize ISynchronize; -typedef struct ISynchronizeContainer ISynchronizeContainer; -typedef struct ISynchronizeEvent ISynchronizeEvent; -typedef struct ISynchronizeHandle ISynchronizeHandle; -typedef struct ISynchronizeMutex ISynchronizeMutex; -typedef struct IThumbnailExtractor IThumbnailExtractor; -typedef struct ITimeAndNoticeControl ITimeAndNoticeControl; -typedef struct ITimer ITimer; -typedef struct ITimerService ITimerService; -typedef struct ITimerSink ITimerSink; -typedef struct ITypeChangeEvents ITypeChangeEvents; -typedef struct ITypeComp ITypeComp; -typedef struct ITypeFactory ITypeFactory; -typedef struct ITypeInfo ITypeInfo; -typedef struct ITypeInfo2 ITypeInfo2; -typedef struct ITypeLib ITypeLib; -typedef struct ITypeLib2 ITypeLib2; -typedef struct ITypeMarshal ITypeMarshal; -typedef struct IUnknown IUnknown; -typedef struct IUrlHistoryNotify IUrlHistoryNotify; -typedef struct IUrlHistoryStg IUrlHistoryStg; -typedef struct IUrlHistoryStg2 IUrlHistoryStg2; -typedef struct IUrlMon IUrlMon; -typedef struct IVariantChangeType IVariantChangeType; -typedef struct IViewObject IViewObject; -typedef struct IViewObject2 IViewObject2; -typedef struct IViewObjectEx IViewObjectEx; -typedef struct IWaitMultiple IWaitMultiple; -typedef struct IWebBrowser IWebBrowser; -typedef struct IWebBrowser2 IWebBrowser2; -typedef struct IWebBrowserApp IWebBrowserApp; -typedef struct IWinInetHttpInfo IWinInetHttpInfo; -typedef struct IWinInetInfo IWinInetInfo; -typedef struct IWindowForBindingUI IWindowForBindingUI; -typedef struct IWrappedProtocol IWrappedProtocol; -typedef struct IXMLAttribute IXMLAttribute; -typedef struct IXMLDOMAttribute IXMLDOMAttribute; -typedef struct IXMLDOMCDATASection IXMLDOMCDATASection; -typedef struct IXMLDOMCharacterData IXMLDOMCharacterData; -typedef struct IXMLDOMComment IXMLDOMComment; -typedef struct IXMLDOMDocument IXMLDOMDocument; -typedef struct IXMLDOMDocumentFragment IXMLDOMDocumentFragment; -typedef struct IXMLDOMDocumentType IXMLDOMDocumentType; -typedef struct IXMLDOMElement IXMLDOMElement; -typedef struct IXMLDOMEntity IXMLDOMEntity; -typedef struct IXMLDOMEntityReference IXMLDOMEntityReference; -typedef struct IXMLDOMImplementation IXMLDOMImplementation; -typedef struct IXMLDOMNamedNodeMap IXMLDOMNamedNodeMap; -typedef struct IXMLDOMNode IXMLDOMNode; -typedef struct IXMLDOMNodeList IXMLDOMNodeList; -typedef struct IXMLDOMNotation IXMLDOMNotation; -typedef struct IXMLDOMParseError IXMLDOMParseError; -typedef struct IXMLDOMProcessingInstruction IXMLDOMProcessingInstruction; -typedef struct IXMLDOMText IXMLDOMText; -typedef struct IXMLDSOControl IXMLDSOControl; -typedef struct IXMLDocument IXMLDocument; -typedef struct IXMLDocument2 IXMLDocument2; -typedef struct IXMLElement IXMLElement; -typedef struct IXMLElement2 IXMLElement2; -typedef struct IXMLElementCollection IXMLElementCollection; -typedef struct IXMLError IXMLError; -typedef struct IXMLHttpRequest IXMLHttpRequest; -typedef struct IXTLRuntime IXTLRuntime; -typedef struct OLEDBSimpleProvider OLEDBSimpleProvider; -typedef struct OLEDBSimpleProviderListener OLEDBSimpleProviderListener; -typedef struct XMLDOMDocumentEvents XMLDOMDocumentEvents; - -typedef struct DOMDocument DOMDocument; -typedef struct DOMFreeThreadedDocument DOMFreeThreadedDocument; -typedef struct XMLDSOControl XMLDSOControl; -typedef struct XMLDocument XMLDocument; -typedef struct XMLHTTPRequest XMLHTTPRequest; diff --git a/libmsi/winstubs/winuser.h b/libmsi/winstubs/winuser.h deleted file mode 100644 index 2241efe..0000000 --- a/libmsi/winstubs/winuser.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifndef _WINUSER_ -#define _WINUSER_ - -#include <_mingw_unicode.h> - -#define wvsprintf __MINGW_NAME_AW(wvsprintf) -#define wsprintf __MINGW_NAME_AW(wsprintf) - -int WINAPI wvsprintfA(LPSTR,LPCSTR,va_list arglist); -int WINAPI wvsprintfW(LPWSTR,LPCWSTR,va_list arglist); -int WINAPIV wsprintfA(LPSTR,LPCSTR,...); -int WINAPIV wsprintfW(LPWSTR,LPCWSTR,...); - -#endif diff --git a/tests/Makefile.am b/tests/Makefile.am index 20f7299..cced9d6 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -1,6 +1,7 @@ AM_CPPFLAGS = -I$(top_srcdir)/include -I$(srcdir) -I. \ $(GLIB_CFLAGS) $(GOBJECT_CFLAGS) +dist_noinst_HEADERS = test.h noinst_PROGRAMS = testrecord testdatabase testrecord_SOURCES = testrecord.c diff --git a/tests/test.h b/tests/test.h index 72234df..3085f89 100644 --- a/tests/test.h +++ b/tests/test.h @@ -1,6 +1,6 @@ #include <stdarg.h> #include <stdbool.h> -#include "debug.h" +#include <stdio.h> #define todo_wine if(0) diff --git a/tests/testdatabase.c b/tests/testdatabase.c index 38d1267..4f8e215 100644 --- a/tests/testdatabase.c +++ b/tests/testdatabase.c @@ -8189,7 +8189,9 @@ void main() test_binary_import(); test_markers(); test_handle_limit(); +#if 0 test_try_transform(); +#endif test_join(); test_temporary_table(); test_alter(); @@ -8199,15 +8201,21 @@ void main() test_tables_order(); test_rows_order(); test_select_markers(); +#if 0 test_stringtable(); +#endif test_defaultdatabase(); test_order(); +#if 0 test_deleterow(); +#endif test_quotes(); test_carriagereturn(); test_noquotes(); test_forcecodepage(); +#if 0 test_storages_table(); +#endif test_droptable(); #if 0 test_dbmerge(); @@ -8216,7 +8224,9 @@ void main() test_insertorder(); test_columnorder(); test_suminfo_import(); +#if 0 test_createtable(); +#endif test_collation(); test_embedded_nulls(); test_select_column_names(); diff --git a/tests/testsuminfo.c b/tests/testsuminfo.c index 3395013..796ae39 100644 --- a/tests/testsuminfo.c +++ b/tests/testsuminfo.c @@ -20,6 +20,7 @@ #define COBJMACROS +#include <stdint.h> #include <stdio.h> #include <windows.h> #include <libmsi.h> diff --git a/tools/msibuild.c b/tools/msibuild.c index c462750..3f5d318 100644 --- a/tools/msibuild.c +++ b/tools/msibuild.c @@ -24,6 +24,7 @@ #include <unistd.h> #include <sys/stat.h> #include <libmsi.h> +#include <limits.h> #ifdef HAVE_LIBUUID #include <uuid.h> |