pax_global_header00006660000000000000000000000064140260670400014511gustar00rootroot0000000000000052 comment=aa60557dc59b7aeeda5aaf694c71b7649340ab2f libldm-libldm-0.2.5/000077500000000000000000000000001402606704000142215ustar00rootroot00000000000000libldm-libldm-0.2.5/.gitignore000066400000000000000000000007471402606704000162210ustar00rootroot00000000000000# Specific build artifacts /aclocal.m4 /autom4te.cache/ /build-aux/ /config.h /config.h.in /config.log /config.status /configure /ldm-1.0.pc /libldm-*/ /libldm-*.tar.gz /libtool /m4/libtool.m4 /m4/lt~obsolete.m4 /m4/ltoptions.m4 /m4/ltsugar.m4 /m4/ltversion.m4 /stamp-h1 # Generic build artifacts .libs/ .deps/ Makefile Makefile.in *.o *.la *.lo # Random exclusions .gdb_history # Generated binaries /src/ldmtool /test/partread /test/ldmread /libldm.spec # Temporary files .*.swp *~ libldm-libldm-0.2.5/COPYING.gpl000066400000000000000000001045131402606704000160410ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. 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 them 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 prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. 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. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey 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; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If 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 convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. 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. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 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. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. 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 state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 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 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 . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program 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, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU 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 Lesser General Public License instead of this License. But first, please read . libldm-libldm-0.2.5/COPYING.lgpl000066400000000000000000000167431402606704000162240ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. 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 that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU 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 as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. libldm-libldm-0.2.5/Makefile.am000066400000000000000000000016341402606704000162610ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . ACLOCAL_AMFLAGS = -I m4 DISTCHECK_CONFIGURE_FLAGS=--enable-gtk-doc SUBDIRS = src test docs/reference/libldm docs/reference/ldmtool pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = ldm-1.0.pc EXTRA_DIST = libldm.spec COPYING.lgpl COPYING.gpl libldm-libldm-0.2.5/README000066400000000000000000000005661402606704000151100ustar00rootroot00000000000000libldm is a tool and library for managing Microsoft Windows Dynamic Disks. Please send patches to libguestfs@redhat.com (you don't need to subscribe). WARNING! Running the test suite (‘make check’) will run various dmsetup commands as root using sudo. Although this shouldn't be unsafe, it's probably a good idea to only run the test suite inside a virtual machine. libldm-libldm-0.2.5/autogen.sh000077500000000000000000000022401402606704000162200ustar00rootroot00000000000000#!/bin/bash # libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . set -e set -v # Create the m4 include directory mkdir -p m4 # Initialise gtk-doc gtkdocize # Initialize autotools autoreconf -i CONFIGUREDIR=. # Run configure in BUILDDIR if it's set if [ ! -z "$BUILDDIR" ]; then mkdir -p $BUILDDIR cd $BUILDDIR CONFIGUREDIR=.. fi # If no arguments were specified and configure has run before, use the previous # arguments if test $# == 0 && test -x ./config.status; then ./config.status --recheck else $CONFIGUREDIR/configure "$@" fi libldm-libldm-0.2.5/configure.ac000066400000000000000000000056441402606704000165200ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . AC_PREREQ([2.68]) AC_INIT([libldm], [0.2.5], [mbooth@redhat.com]) AC_CONFIG_AUX_DIR([build-aux]) AC_CONFIG_SRCDIR([src/ldm.c]) AC_CONFIG_HEADERS([config.h]) AM_INIT_AUTOMAKE([foreign]) # Define _GNU_SOURCE etc. AC_USE_SYSTEM_EXTENSIONS AC_PATH_PROG([XSLTPROC], [xsltproc]) m4_ifndef([AM_SILENT_RULES], [m4_define([AM_SILENT_RULES],[])]) AM_SILENT_RULES([yes]) # make --enable-silent-rules the default. AC_CONFIG_MACRO_DIR([m4]) # Checks for programs. AC_PROG_CC_C99 LT_INIT AC_CHECK_LIB([readline], [readline], [], [AC_MSG_ERROR([readline library is missing])]) # Checks for libraries. AC_CHECK_FUNCS([bzero strerror]) AC_FUNC_MALLOC # Checks for header files. AC_CHECK_HEADERS( [ fcntl.h \ stdint.h \ stdlib.h \ string.h \ sys/ioctl.h \ unistd.h ], [], [AC_MSG_ERROR([At least 1 required header file is missing])] ) AC_HEADER_MAJOR # Checks for typedefs, structures, and compiler characteristics. AC_TYPE_OFF_T AC_TYPE_SIZE_T AC_TYPE_SSIZE_T AC_TYPE_UINT16_T AC_TYPE_UINT32_T AC_TYPE_UINT64_T AC_TYPE_UINT8_T PKG_CHECK_MODULES([GOBJECT], [gobject-2.0 >= 2.26.0], [ AC_SUBST([GOBJECT_CFLAGS]) AC_SUBST([GOBJECT_LIBS]) ] ) PKG_CHECK_MODULES([JSON], [json-glib-1.0 >= 0.14.0], [ AC_SUBST([JSON_CFLAGS]) AC_SUBST([JSON_LIBS]) ] ) PKG_CHECK_MODULES([GIO_UNIX], [gio-unix-2.0 >= 2.32.0], [ AC_SUBST([GIO_UNIX_CFLAGS]) AC_SUBST([GIO_UNIX_LIBS]) ] ) PKG_CHECK_MODULES([ZLIB], [zlib >= 1.2], [ AC_SUBST([ZLIB_CFLAGS]) AC_SUBST([ZLIB_LIBS]) ] ) PKG_CHECK_MODULES([UUID], [uuid], [ AC_SUBST([UUID_CFLAGS]) AC_SUBST([UUID_LIBS]) ] ) PKG_CHECK_MODULES([DEVMAPPER], [devmapper >= 1.02], [ AC_SUBST([DEVMAPPER_CFLAGS]) AC_SUBST([DEVMAPPER_LIBS]) ] ) # GObject Introspection is not working. See comment in src/Makefile.am # GOBJECT_INTROSPECTION_CHECK([1.30.0]) GTK_DOC_CHECK([1.14], [--flavour no-tmpl]) # Checks for library functions. AC_CONFIG_FILES([Makefile]) AC_CONFIG_FILES([src/Makefile]) AC_CONFIG_FILES([test/Makefile]) AC_CONFIG_FILES([docs/reference/libldm/Makefile]) AC_CONFIG_FILES([docs/reference/ldmtool/Makefile]) AC_CONFIG_FILES([ldm-1.0.pc]) AC_CONFIG_FILES([libldm.spec]) AC_OUTPUT libldm-libldm-0.2.5/docs/000077500000000000000000000000001402606704000151515ustar00rootroot00000000000000libldm-libldm-0.2.5/docs/reference/000077500000000000000000000000001402606704000171075ustar00rootroot00000000000000libldm-libldm-0.2.5/docs/reference/ldmtool/000077500000000000000000000000001402606704000205615ustar00rootroot00000000000000libldm-libldm-0.2.5/docs/reference/ldmtool/.gitignore000066400000000000000000000000371402606704000225510ustar00rootroot00000000000000# Generated man page ldmtool.1 libldm-libldm-0.2.5/docs/reference/ldmtool/Makefile.am000066400000000000000000000015631402606704000226220ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . man_MANS = ldmtool.1 %.1: %.xml @XSLTPROC@ -nonet http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl $< BUILT_EXTRA_DIST = $(man_MANS) EXTRA_DIST = ldmtool.xml CLEANFILES = ldmtool.1 libldm-libldm-0.2.5/docs/reference/ldmtool/ldmtool.xml000066400000000000000000000522611402606704000227630ustar00rootroot00000000000000 ldmtool Matthew Booth mbooth@redhat.com Primary developer ldmtool 1 User Commands ldmtool A tool to manage Microsoft Windows dynamic disks ldmtool options ldmtool options scan device ldmtool options show diskgroup disk group GUID ldmtool options show volume partition disk disk group GUID object name ldmtool options create remove all ldmtool options create remove volume disk group GUID volume name Options device Automatically scan device. Description ldmtool is a tool for managing Microsoft Windows dynamic disks, which use Microsoft's LDM metadata. It can inspect them, and also create and remove device-mapper block devices which can be mounted. Although a filesystem can be mounted read-write and its contents modified, ldmtool is not able to modify the LDM metadata itself. That is, it cannot create, remove or edit dynamic disks. It is also not able to mount RAID5 volumes which have a partition missing, although it can mount mirrored volumes with a partition missing. However, mounting a volume with a missing partition is not recommended, as ldmtool does not update the LDM metadata in any way. This means Windows will have no way to determine that the partitions are not synchronised when it subsequently mounted, which may result in corruption. Invocation ldmtool can be invoked either as a shell to run multiple actions, or to run a single action and return. If an action is given on the command line it will run in single action mode. If no action is given it will launch a shell. Shell mode When invoked as a shell, ldmtool will not scan any block devices by default. If any block devices are given on the command line with the option, these will be scanned. Otherwise, block devices must be scanned explicitly with the action. Exit shell mode by sending an EOF, or with the quit or exit actions. Single action mode When invoked to run a single action all block devices will be scanned by default. In this case, if any block devices are specified with the option, only those block devices will be scanned. Results ldmtool returns results as JSON-formatted data. The precise data returned is described in detail below. If a command fails it will not return any JSON data, but will instead display an error message. In shell mode, failure can be detected by the lack of a JSON-formatted result. In single action mode the caller can additionally check the exit code of the command. Actions <command>scan</command> <arg choice='opt' rep='repeat'>device</arg> Scan all devices for LDM metadata. Returns a list of all known disk group GUIDs. Note that it doesn't just return newly discovered disk groups. <command>show</command> diskgroup <arg choice='req'><replaceable>GUID</replaceable></arg> Return detailed information about a single disk group. Returns: name The human-readable name of the disk group guid The Windows-assigned GUID of the disk group volumes A list of the names of all volumes in the disk group disks A list of the name of all disks in the disk group <command>show</command> volume <arg choice='req'><replaceable>disk group GUID</replaceable></arg> <arg choice='req'><replaceable>volume name</replaceable></arg> Return detailed information about a volume. Returns: name The name of the volume guid The Windows-assigned GUID of the volume type The volume type. One of: simple spanned striped mirrored raid5 size The size of the volume in sectors chunk-size The chunk size, in sectors, used by striped and raid5 volumes. For other volume types it will be 0. hint The volume mounting hint. This value specifies how Windows expects the volume to be mounted. For a volume with an assigned drive letter, it might be 'E:'. device The host device-mapper device which was created for this volume if any (e.g. /dev/mapper/ldm_vol_Machine-Dg0_Volume1) partitions A list of the names of the partitions which constitute this volume. <command>show</command> partition <arg choice='req'><replaceable>disk group GUID</replaceable></arg> <arg choice='req'><replaceable>partition name</replaceable></arg> Return detailed information about a partition. Returns: name The name of the partition start The offset, in sectors, of the start of the partition from the beginning of the disk size The size of the partition in sectors disk The name of the disk the partition is on <command>show</command> disk <arg choice='req'><replaceable>disk group GUID</replaceable></arg> <arg choice='req'><replaceable>disk name</replaceable></arg> Return detailed information about a disk. Returns: name The human-readable name of the disk guid The GUID of the disk present Whether the disk has been discovered during scanning: true or false If the disk is present, additionally returns: device The name of the host device (e.g. /dev/sda) data-start The start sector of the data portion of the disk data-size The size, in sectors, of the data portion of the disk metadata-start The start sector of the metadata portion of the disk metadata-size The size, in sectors, of the metadata portion of the disk <command>create</command> <group choice='req'> <arg choice='plain'> <arg choice='plain'>volume</arg> <arg choice='req'> <replaceable>disk group GUID</replaceable> </arg> <arg choice='req'> <replaceable>volume name</replaceable> </arg> </arg> <arg choice='plain'>all</arg> </group> Create a device-mapper device for either the specified volume or all volumes in all detected disk groups. Returns a list of the device-mapper device names which were created by this action. Note that if a device already existed for a volume it will not be returned in this list. <command>remove</command> <group choice='req'> <arg choice='plain'> <arg choice='plain'>volume</arg> <arg choice='req'> <replaceable>disk group GUID</replaceable> </arg> <arg choice='req'> <replaceable>volume name</replaceable> </arg> </arg> <arg choice='plain'>all</arg> </group> Remove device-mapper devices for either the specified volume or all volumes in all detected disk groups. Returns a list of the device-mapper device names which were removed by this action. Note that if no device existed for a volume it will not be returned in this list. Examples The following examples form a sequence from a single session of ldmtool running in shell mode. Scan all loop devices for LDM metadata: scan /dev/loop[0-9]* [ "03c0c4fc-8b6f-402b-9431-4be2e5823b1c", "06495a84-fbfd-11e1-8cf9-52540061f5db" ] ]]> Two disk groups were detected. The list contains their GUIDs. Show detailed information about one of the disk groups: show diskgroup 06495a84-fbfd-11e1-8cf9-52540061f5db { "name" : "WIN-ERRDJSBDAVF-Dg0", "guid" : "06495a84-fbfd-11e1-8cf9-52540061f5db", "volumes" : [ "Volume4", "Volume1", "Volume2", "Volume3", "Volume5" ], "disks" : [ "Disk1", "Disk2", "Disk3", "Disk4", "Disk5", "Disk6", "Disk7", "Disk8", "Disk9" ] } ]]> Show detailed information about one of the volumes in the disk group: show volume 06495a84-fbfd-11e1-8cf9-52540061f5db Volume1 { "name" : "Volume1", "guid" : "c08309e9-1d30-43e5-8dc3-fcec8be76fcc", "type" : "spanned", "size" : 129024, "chunk-size" : 0, "hint" : "E:", "device" : "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1", "partitions" : [ "Disk1-01", "Disk2-01" ] } ]]> Show detailed information about one of the partitions in the volume: show partition 06495a84-fbfd-11e1-8cf9-52540061f5db Disk1-01 { "name" : "Disk1-01", "start" : 65, "size" : 96256, "disk" : "Disk1" } ]]> Show detailed information about the disk containing the partition: show disk 06495a84-fbfd-11e1-8cf9-52540061f5db Disk1 { "name" : "Disk1", "guid" : "06495a85-fbfd-11e1-8cf9-52540061f5db", "present" : true, "device" : "/dev/loop15", "data-start" : 63, "data-size" : 100289, "metadata-start" : 100352, "metadata-size" : 2048 } ]]> Create a device-mapper device for a volume: create volume 06495a84-fbfd-11e1-8cf9-52540061f5db Volume1 [ "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1" ] ]]> A new device-mapper device has been created, called ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1. Depending on how udev is configured, it will probably now be available as /dev/mapper/ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1. Note that returned name of the created device-mapper device is unmangled and thus can contains not-whitelisted characters. User-space device-mapper tools (like dmsetup) and libdevmapper library accept unmangled names (if properly configured) but take extra care composing path to a created device yourself. Consider using "device" field of the show volume command output. Create device-mapper devices for all volumes in both disk groups: create all [ "ldm_vol_Red-nzv8x6obywgDg0_Volume2", "ldm_vol_Red-nzv8x6obywgDg0_Volume1", "ldm_vol_Red-nzv8x6obywgDg0_Volume4", "ldm_vol_Red-nzv8x6obywgDg0_Stripe1", "ldm_vol_Red-nzv8x6obywgDg0_Raid1", "ldm_vol_Red-nzv8x6obywgDg0_Volume3", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume4", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume2", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume3", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume5" ] ]]> Note that ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1 is not in the list of devices which were created as it already existed. Remove the device-mapper device for a single volume: remove volume 06495a84-fbfd-11e1-8cf9-52540061f5db Volume2 [ "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume2" ] ]]> remove all [ "ldm_vol_Red-nzv8x6obywgDg0_Volume2", "ldm_vol_Red-nzv8x6obywgDg0_Volume1", "ldm_vol_Red-nzv8x6obywgDg0_Volume4", "ldm_vol_Red-nzv8x6obywgDg0_Stripe1", "ldm_vol_Red-nzv8x6obywgDg0_Raid1", "ldm_vol_Red-nzv8x6obywgDg0_Volume3", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume4", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume1", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume3", "ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume5" ] ]]> Note that ldm_vol_WIN-ERRDJSBDAVF-Dg0_Volume2 is not in the list of devices which were removed, as it was removed previously. libldm-libldm-0.2.5/docs/reference/libldm/000077500000000000000000000000001402606704000203525ustar00rootroot00000000000000libldm-libldm-0.2.5/docs/reference/libldm/.gitignore000066400000000000000000000005041402606704000223410ustar00rootroot00000000000000# gtk-doc spam /html-build.stamp /html.stamp /html/ /*-decl-list.txt /*-decl.txt /*-docs.sgml /*-overrides.txt /*-sections.txt /*-undeclared.txt /*-undocumented.txt /*-unused.txt /*.args /*.hierarchy /*.interfaces /*.prerequisites /*.signals /*.types /scan-build.stamp /setup-build.stamp /sgml-build.stamp /sgml.stamp /xml/ libldm-libldm-0.2.5/docs/reference/libldm/Makefile.am000066400000000000000000000105661402606704000224160ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . libname=libldm-1.0.la lib=$(top_builddir)/src/$(libname) # We include built sgml and html in dist dist-hook: sgml-build.stamp html-build.stamp # We require automake 1.6 at least. AUTOMAKE_OPTIONS = 1.6 # The name of the module, e.g. 'glib'. DOC_MODULE=libldm # Uncomment for versioned docs and specify the version of the module, e.g. '2'. #DOC_MODULE_VERSION=2 # Introduce an explicit dependency on the library. This ensure that the docs # will be rebuilt if the library is updated, and that the docs build will # succeed if the library hasn't been built yet. # This is required for distcheck to succeed on a fresh checkout. scan-build.stamp: $(lib) $(lib): $(MAKE) $(AM_MAKEFLAGS) -C $(top_srcdir)/src $(libname) # The top-level SGML file. You can change this if you want to. DOC_MAIN_SGML_FILE=$(DOC_MODULE)-docs.sgml # Directories containing the source code. # gtk-doc will search all .c and .h files beneath these paths # for inline comments documenting functions and macros. # e.g. DOC_SOURCE_DIR=$(top_srcdir)/gtk $(top_srcdir)/gdk DOC_SOURCE_DIR=$(top_srcdir)/src # Extra options to pass to gtkdoc-scangobj. Not normally needed. SCANGOBJ_OPTIONS= # Extra options to supply to gtkdoc-scan. # e.g. SCAN_OPTIONS=--deprecated-guards="GTK_DISABLE_DEPRECATED" SCAN_OPTIONS= # Extra options to supply to gtkdoc-mkdb. # e.g. MKDB_OPTIONS=--xml-mode --output-format=xml MKDB_OPTIONS=--xml-mode --output-format=xml # Extra options to supply to gtkdoc-mktmpl # e.g. MKTMPL_OPTIONS=--only-section-tmpl MKTMPL_OPTIONS= # Extra options to supply to gtkdoc-mkhtml MKHTML_OPTIONS= # Extra options to supply to gtkdoc-fixref. Not normally needed. # e.g. FIXXREF_OPTIONS=--extra-dir=../gdk-pixbuf/html --extra-dir=../gdk/html FIXXREF_OPTIONS= # Used for dependencies. The docs will be rebuilt if any of these change. # e.g. HFILE_GLOB=$(top_srcdir)/gtk/*.h # e.g. CFILE_GLOB=$(top_srcdir)/gtk/*.c HFILE_GLOB=$(top_srcdir)/src/ldm.h CFILE_GLOB=$(top_srcdir)/src/ldm.c # Extra header to include when scanning, which are not under DOC_SOURCE_DIR # e.g. EXTRA_HFILES=$(top_srcdir}/contrib/extra.h EXTRA_HFILES= # Header files or dirs to ignore when scanning. Use base file/dir names # e.g. IGNORE_HFILES=gtkdebug.h gtkintl.h private_code IGNORE_HFILES=gpt.h mbr.h # Images to copy into HTML directory. # e.g. HTML_IMAGES=$(top_srcdir)/gtk/stock-icons/stock_about_24.png HTML_IMAGES= # Extra SGML files that are included by $(DOC_MAIN_SGML_FILE). # e.g. content_files=running.sgml building.sgml changes-2.0.sgml content_files= # SGML files where gtk-doc abbrevations (#GtkWidget) are expanded # These files must be listed here *and* in content_files # e.g. expand_content_files=running.sgml expand_content_files= # CFLAGS and LDFLAGS for compiling gtkdoc-scangobj with your library. # Only needed if you are using gtkdoc-scangobj to dynamically query widget # signals and properties. # e.g. GTKDOC_CFLAGS=-I$(top_srcdir) -I$(top_builddir) $(GTK_DEBUG_FLAGS) # e.g. GTKDOC_LIBS=$(top_builddir)/gtk/$(gtktargetlib) GTKDOC_CFLAGS=$(DEVMAPPER_LIBS) GTKDOC_LIBS=$(lib) $(DEVMAPPER_LIBS) # This includes the standard gtk-doc make rules, copied by gtkdocize. include $(top_srcdir)/gtk-doc.make # Other files to distribute # e.g. EXTRA_DIST += version.xml.in EXTRA_DIST += # Files not to distribute # for --rebuild-types in $(SCAN_OPTIONS), e.g. $(DOC_MODULE).types # for --rebuild-sections in $(SCAN_OPTIONS) e.g. $(DOC_MODULE)-sections.txt #DISTCLEANFILES += # Comment this out if you want 'make check' to test you doc status # and run some sanity checks if ENABLE_GTK_DOC TESTS_ENVIRONMENT = cd $(srcdir) && \ DOC_MODULE=$(DOC_MODULE) DOC_MAIN_SGML_FILE=$(DOC_MAIN_SGML_FILE) \ SRCDIR=$(abs_srcdir) BUILDDIR=$(abs_builddir) #TESTS = $(GTKDOC_CHECK) endif -include $(top_srcdir)/git.mk libldm-libldm-0.2.5/gtk-doc.make000077500000000000000000000250401402606704000164140ustar00rootroot00000000000000# -*- mode: makefile -*- # # gtk-doc.make - make rules for gtk-doc # Copyright (C) 2003 James Henstridge # 2004-2007 Damon Chaplin # 2007-2017 Stefan Sauer # # 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 # (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, see . #################################### # Everything below here is generic # #################################### if GTK_DOC_USE_LIBTOOL GTKDOC_CC = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(INCLUDES) $(GTKDOC_DEPS_CFLAGS) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) GTKDOC_LD = $(LIBTOOL) --tag=CC --mode=link $(CC) $(GTKDOC_DEPS_LIBS) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) GTKDOC_RUN = $(LIBTOOL) --mode=execute else GTKDOC_CC = $(CC) $(INCLUDES) $(GTKDOC_DEPS_CFLAGS) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) GTKDOC_LD = $(CC) $(GTKDOC_DEPS_LIBS) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) GTKDOC_RUN = endif # We set GPATH here; this gives us semantics for GNU make # which are more like other make's VPATH, when it comes to # whether a source that is a target of one rule is then # searched for in VPATH/GPATH. # GPATH = $(srcdir) TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE) SETUP_FILES = \ $(content_files) \ $(expand_content_files) \ $(DOC_MAIN_SGML_FILE) \ $(DOC_MODULE)-sections.txt \ $(DOC_MODULE)-overrides.txt EXTRA_DIST = \ $(HTML_IMAGES) \ $(SETUP_FILES) DOC_STAMPS=setup-build.stamp scan-build.stamp sgml-build.stamp \ html-build.stamp pdf-build.stamp \ sgml.stamp html.stamp pdf.stamp SCANOBJ_FILES = \ $(DOC_MODULE).args \ $(DOC_MODULE).hierarchy \ $(DOC_MODULE).interfaces \ $(DOC_MODULE).prerequisites \ $(DOC_MODULE).signals REPORT_FILES = \ $(DOC_MODULE)-undocumented.txt \ $(DOC_MODULE)-undeclared.txt \ $(DOC_MODULE)-unused.txt gtkdoc-check.test: Makefile $(AM_V_GEN)echo "#!/bin/sh -e" > $@; \ echo "$(GTKDOC_CHECK_PATH) || exit 1" >> $@; \ chmod +x $@ CLEANFILES = $(SCANOBJ_FILES) $(REPORT_FILES) $(DOC_STAMPS) gtkdoc-check.test if GTK_DOC_BUILD_HTML HTML_BUILD_STAMP=html-build.stamp else HTML_BUILD_STAMP= endif if GTK_DOC_BUILD_PDF PDF_BUILD_STAMP=pdf-build.stamp else PDF_BUILD_STAMP= endif all-gtk-doc: $(HTML_BUILD_STAMP) $(PDF_BUILD_STAMP) .PHONY: all-gtk-doc if ENABLE_GTK_DOC all-local: all-gtk-doc endif docs: $(HTML_BUILD_STAMP) $(PDF_BUILD_STAMP) $(REPORT_FILES): sgml-build.stamp #### setup #### GTK_DOC_V_SETUP=$(GTK_DOC_V_SETUP_@AM_V@) GTK_DOC_V_SETUP_=$(GTK_DOC_V_SETUP_@AM_DEFAULT_V@) GTK_DOC_V_SETUP_0=@echo " DOC Preparing build"; setup-build.stamp: -$(GTK_DOC_V_SETUP)if test "$(abs_srcdir)" != "$(abs_builddir)" ; then \ files=`echo $(SETUP_FILES) $(DOC_MODULE).types`; \ if test "x$$files" != "x" ; then \ for file in $$files ; do \ destdir=`dirname $(abs_builddir)/$$file`; \ test -d "$$destdir" || mkdir -p "$$destdir"; \ test -f $(abs_srcdir)/$$file && \ cp -pf $(abs_srcdir)/$$file $(abs_builddir)/$$file || true; \ done; \ fi; \ fi $(AM_V_at)touch setup-build.stamp #### scan #### GTK_DOC_V_SCAN=$(GTK_DOC_V_SCAN_@AM_V@) GTK_DOC_V_SCAN_=$(GTK_DOC_V_SCAN_@AM_DEFAULT_V@) GTK_DOC_V_SCAN_0=@echo " DOC Scanning header files"; GTK_DOC_V_INTROSPECT=$(GTK_DOC_V_INTROSPECT_@AM_V@) GTK_DOC_V_INTROSPECT_=$(GTK_DOC_V_INTROSPECT_@AM_DEFAULT_V@) GTK_DOC_V_INTROSPECT_0=@echo " DOC Introspecting gobjects"; scan-build.stamp: setup-build.stamp $(HFILE_GLOB) $(CFILE_GLOB) $(GTK_DOC_V_SCAN)_source_dir='' ; \ for i in $(DOC_SOURCE_DIR) ; do \ _source_dir="$${_source_dir} --source-dir=$$i" ; \ done ; \ gtkdoc-scan --module=$(DOC_MODULE) --ignore-headers="$(IGNORE_HFILES)" $${_source_dir} $(SCAN_OPTIONS) $(EXTRA_HFILES) $(GTK_DOC_V_INTROSPECT)if grep -l '^..*$$' $(DOC_MODULE).types > /dev/null 2>&1 ; then \ scanobj_options=""; \ gtkdoc-scangobj 2>&1 --help | grep >/dev/null "\-\-verbose"; \ if test "$$?" = "0"; then \ if test "x$(V)" = "x1"; then \ scanobj_options="--verbose"; \ fi; \ fi; \ CC="$(GTKDOC_CC)" LD="$(GTKDOC_LD)" RUN="$(GTKDOC_RUN)" CFLAGS="$(GTKDOC_CFLAGS) $(CFLAGS)" LDFLAGS="$(GTKDOC_LIBS) $(LDFLAGS)" \ gtkdoc-scangobj $(SCANGOBJ_OPTIONS) $$scanobj_options --module=$(DOC_MODULE); \ else \ for i in $(SCANOBJ_FILES) ; do \ test -f $$i || touch $$i ; \ done \ fi $(AM_V_at)touch scan-build.stamp $(DOC_MODULE)-decl.txt $(SCANOBJ_FILES) $(DOC_MODULE)-sections.txt $(DOC_MODULE)-overrides.txt: scan-build.stamp @true #### xml #### GTK_DOC_V_XML=$(GTK_DOC_V_XML_@AM_V@) GTK_DOC_V_XML_=$(GTK_DOC_V_XML_@AM_DEFAULT_V@) GTK_DOC_V_XML_0=@echo " DOC Building XML"; sgml-build.stamp: setup-build.stamp $(DOC_MODULE)-decl.txt $(SCANOBJ_FILES) $(HFILE_GLOB) $(CFILE_GLOB) $(DOC_MODULE)-sections.txt $(DOC_MODULE)-overrides.txt $(expand_content_files) xml/gtkdocentities.ent $(GTK_DOC_V_XML)_source_dir='' ; \ for i in $(DOC_SOURCE_DIR) ; do \ _source_dir="$${_source_dir} --source-dir=$$i" ; \ done ; \ gtkdoc-mkdb --module=$(DOC_MODULE) --output-format=xml --expand-content-files="$(expand_content_files)" --main-sgml-file=$(DOC_MAIN_SGML_FILE) $${_source_dir} $(MKDB_OPTIONS) $(AM_V_at)touch sgml-build.stamp sgml.stamp: sgml-build.stamp @true $(DOC_MAIN_SGML_FILE): sgml-build.stamp @true xml/gtkdocentities.ent: Makefile $(GTK_DOC_V_XML)$(MKDIR_P) $(@D) && ( \ echo ""; \ echo ""; \ echo ""; \ echo ""; \ echo ""; \ echo ""; \ echo ""; \ ) > $@ #### html #### GTK_DOC_V_HTML=$(GTK_DOC_V_HTML_@AM_V@) GTK_DOC_V_HTML_=$(GTK_DOC_V_HTML_@AM_DEFAULT_V@) GTK_DOC_V_HTML_0=@echo " DOC Building HTML"; GTK_DOC_V_XREF=$(GTK_DOC_V_XREF_@AM_V@) GTK_DOC_V_XREF_=$(GTK_DOC_V_XREF_@AM_DEFAULT_V@) GTK_DOC_V_XREF_0=@echo " DOC Fixing cross-references"; html-build.stamp: sgml.stamp $(DOC_MAIN_SGML_FILE) $(content_files) $(expand_content_files) $(GTK_DOC_V_HTML)rm -rf html && mkdir html && \ mkhtml_options=""; \ gtkdoc-mkhtml 2>&1 --help | grep >/dev/null "\-\-verbose"; \ if test "$$?" = "0"; then \ if test "x$(V)" = "x1"; then \ mkhtml_options="$$mkhtml_options --verbose"; \ fi; \ fi; \ gtkdoc-mkhtml 2>&1 --help | grep >/dev/null "\-\-path"; \ if test "$$?" = "0"; then \ mkhtml_options="$$mkhtml_options --path=\"$(abs_srcdir)\""; \ fi; \ cd html && gtkdoc-mkhtml $$mkhtml_options $(MKHTML_OPTIONS) $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE) -@test "x$(HTML_IMAGES)" = "x" || \ for file in $(HTML_IMAGES) ; do \ test -f $(abs_srcdir)/$$file && cp $(abs_srcdir)/$$file $(abs_builddir)/html; \ test -f $(abs_builddir)/$$file && cp $(abs_builddir)/$$file $(abs_builddir)/html; \ test -f $$file && cp $$file $(abs_builddir)/html; \ done; $(GTK_DOC_V_XREF)gtkdoc-fixxref --module=$(DOC_MODULE) --module-dir=html --html-dir=$(HTML_DIR) $(FIXXREF_OPTIONS) $(AM_V_at)touch html-build.stamp #### pdf #### GTK_DOC_V_PDF=$(GTK_DOC_V_PDF_@AM_V@) GTK_DOC_V_PDF_=$(GTK_DOC_V_PDF_@AM_DEFAULT_V@) GTK_DOC_V_PDF_0=@echo " DOC Building PDF"; pdf-build.stamp: sgml.stamp $(DOC_MAIN_SGML_FILE) $(content_files) $(expand_content_files) $(GTK_DOC_V_PDF)rm -f $(DOC_MODULE).pdf && \ mkpdf_options=""; \ gtkdoc-mkpdf 2>&1 --help | grep >/dev/null "\-\-verbose"; \ if test "$$?" = "0"; then \ if test "x$(V)" = "x1"; then \ mkpdf_options="$$mkpdf_options --verbose"; \ fi; \ fi; \ if test "x$(HTML_IMAGES)" != "x"; then \ for img in $(HTML_IMAGES); do \ part=`dirname $$img`; \ echo $$mkpdf_options | grep >/dev/null "\-\-imgdir=$$part "; \ if test $$? != 0; then \ mkpdf_options="$$mkpdf_options --imgdir=$$part"; \ fi; \ done; \ fi; \ gtkdoc-mkpdf --path="$(abs_srcdir)" $$mkpdf_options $(DOC_MODULE) $(DOC_MAIN_SGML_FILE) $(MKPDF_OPTIONS) $(AM_V_at)touch pdf-build.stamp ############## clean-local: @rm -f *~ *.bak @rm -rf .libs @if echo $(SCAN_OPTIONS) | grep -q "\-\-rebuild-types" ; then \ rm -f $(DOC_MODULE).types; \ fi @if echo $(SCAN_OPTIONS) | grep -q "\-\-rebuild-sections" ; then \ rm -f $(DOC_MODULE)-sections.txt; \ fi distclean-local: @rm -rf xml html $(REPORT_FILES) $(DOC_MODULE).pdf \ $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt @if test "$(abs_srcdir)" != "$(abs_builddir)" ; then \ rm -f $(SETUP_FILES) $(DOC_MODULE).types; \ fi maintainer-clean-local: @rm -rf xml html install-data-local: @installfiles=`echo $(builddir)/html/*`; \ if test "$$installfiles" = '$(builddir)/html/*'; \ then echo 1>&2 'Nothing to install' ; \ else \ if test -n "$(DOC_MODULE_VERSION)"; then \ installdir="$(DESTDIR)$(TARGET_DIR)-$(DOC_MODULE_VERSION)"; \ else \ installdir="$(DESTDIR)$(TARGET_DIR)"; \ fi; \ $(mkinstalldirs) $${installdir} ; \ for i in $$installfiles; do \ echo ' $(INSTALL_DATA) '$$i ; \ $(INSTALL_DATA) $$i $${installdir}; \ done; \ if test -n "$(DOC_MODULE_VERSION)"; then \ mv -f $${installdir}/$(DOC_MODULE).devhelp2 \ $${installdir}/$(DOC_MODULE)-$(DOC_MODULE_VERSION).devhelp2; \ fi; \ $(GTKDOC_REBASE) --relative --dest-dir=$(DESTDIR) --html-dir=$${installdir}; \ fi uninstall-local: @if test -n "$(DOC_MODULE_VERSION)"; then \ installdir="$(DESTDIR)$(TARGET_DIR)-$(DOC_MODULE_VERSION)"; \ else \ installdir="$(DESTDIR)$(TARGET_DIR)"; \ fi; \ rm -rf $${installdir} # # Require gtk-doc when making dist # if HAVE_GTK_DOC dist-check-gtkdoc: docs else dist-check-gtkdoc: @echo "*** gtk-doc is needed to run 'make dist'. ***" @echo "*** gtk-doc was not found when 'configure' ran. ***" @echo "*** please install gtk-doc and rerun 'configure'. ***" @false endif dist-hook: dist-check-gtkdoc all-gtk-doc dist-hook-local @mkdir $(distdir)/html @cp ./html/* $(distdir)/html @-cp ./$(DOC_MODULE).pdf $(distdir)/ @-cp ./$(DOC_MODULE).types $(distdir)/ @-cp ./$(DOC_MODULE)-sections.txt $(distdir)/ @cd $(distdir) && rm -f $(DISTCLEANFILES) @$(GTKDOC_REBASE) --online --relative --html-dir=$(distdir)/html .PHONY : dist-hook-local docs libldm-libldm-0.2.5/ldm-1.0.pc.in000066400000000000000000000005461402606704000162270ustar00rootroot00000000000000prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: LDM Description: Microsoft Windows LDM device management library Requires: gobject-2.0 >= 2.26.0 glib-2.0 Requires.private: json-glib-1.0 >= 0.14.0 gio-unix-2.0 >= 2.32.0 devmapper >= 1.02 Version: @VERSION@ Libs: -L${libdir} -lldm-1.0 Libs.private: -lz -luuid Cflags: libldm-libldm-0.2.5/libldm.spec.in000066400000000000000000000027771402606704000167620ustar00rootroot00000000000000Name: libldm Version: @VERSION@ Release: 1%{?dist}%{?extra_release} Summary: A tool to manage Windows dynamic disks License: LGPLv3+ and GPLv3+ URL: https://github.com/mdbooth/libldm Source0: %{url}/downloads/%{name}-%{version}.tar.gz BuildRequires: glib2-devel >= 2.26.0 BuildRequires: json-glib-devel >= 0.14.0 BuildRequires: device-mapper-devel >= 1.02 BuildRequires: zlib-devel libuuid-devel readline-devel %description libldm is a library for managing Microsoft Windows dynamic disks, which use Microsoft's LDM metadata. It can inspect them, and also create and remove device-mapper block devices which can be mounted. It includes ldmtool, which exposes this functionality as a command-line tool. libldm is released under LGPLv3+. ldmtool is released under GPLv3+. %package devel Summary: Development files for %{name} Requires: %{name}%{?_isa} = %{version}-%{release} %description devel The %{name}-devel package contains libraries and header files for developing applications that use %{name}. %prep %setup -q %build %configure --disable-static --enable-gtk-doc make %{?_smp_mflags} %install %make_install find $RPM_BUILD_ROOT -name '*.la' -exec rm -f {} ';' %post -p /sbin/ldconfig %postun -p /sbin/ldconfig %files %doc COPYING.lgpl COPYING.gpl %{_libdir}/*.so.* %{_bindir}/ldmtool %{_mandir}/man1/ldmtool.1.gz %files devel %{_includedir}/* %{_libdir}/*.so %{_libdir}/pkgconfig/ldm-1.0.pc %{_datadir}/gtk-doc %changelog libldm-libldm-0.2.5/m4/000077500000000000000000000000001402606704000145415ustar00rootroot00000000000000libldm-libldm-0.2.5/m4/.exists000066400000000000000000000000021402606704000160510ustar00rootroot00000000000000. libldm-libldm-0.2.5/m4/gtk-doc.m4000077500000000000000000000106601402606704000163410ustar00rootroot00000000000000# -*- mode: autoconf -*- # # gtk-doc.m4 - configure macro to check for gtk-doc # Copyright (C) 2003 James Henstridge # 2007-2017 Stefan Sauer # # 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 # (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, see . # # As a special exception, the above copyright owner gives unlimited # permission to copy, distribute and modify the configure scripts that # are the output of Autoconf when processing the Macro. You need not # follow the terms of the GNU General Public License when using or # distributing such scripts, even though portions of the text of the # Macro appear in them. The GNU General Public License (GPL) does govern # all other use of the material that constitutes the Autoconf Macro. # serial 2 dnl Usage: dnl GTK_DOC_CHECK([minimum-gtk-doc-version]) AC_DEFUN([GTK_DOC_CHECK], [ AC_REQUIRE([PKG_PROG_PKG_CONFIG]) AC_BEFORE([AC_PROG_LIBTOOL],[$0])dnl setup libtool first AC_BEFORE([AM_PROG_LIBTOOL],[$0])dnl setup libtool first ifelse([$1],[],[gtk_doc_requires="gtk-doc"],[gtk_doc_requires="gtk-doc >= $1"]) AC_MSG_CHECKING([for gtk-doc]) PKG_CHECK_EXISTS([$gtk_doc_requires],[have_gtk_doc=yes],[have_gtk_doc=no]) AC_MSG_RESULT($have_gtk_doc) if test "$have_gtk_doc" = "no"; then AC_MSG_WARN([ You will not be able to create source packages with 'make dist' because $gtk_doc_requires is not found.]) fi dnl check for tools we added during development dnl Use AC_CHECK_PROG to avoid the check target using an absolute path that dnl may not be writable by the user. Currently, automake requires that the dnl test name must end in '.test'. dnl https://bugzilla.gnome.org/show_bug.cgi?id=701638 AC_CHECK_PROG([GTKDOC_CHECK],[gtkdoc-check],[gtkdoc-check.test]) AC_PATH_PROG([GTKDOC_CHECK_PATH],[gtkdoc-check]) AC_PATH_PROGS([GTKDOC_REBASE],[gtkdoc-rebase],[true]) AC_PATH_PROG([GTKDOC_MKPDF],[gtkdoc-mkpdf]) dnl for overriding the documentation installation directory AC_ARG_WITH([html-dir], AS_HELP_STRING([--with-html-dir=PATH], [path to installed docs]),, [with_html_dir='${datadir}/gtk-doc/html']) HTML_DIR="$with_html_dir" AC_SUBST([HTML_DIR]) dnl enable/disable documentation building AC_ARG_ENABLE([gtk-doc], AS_HELP_STRING([--enable-gtk-doc], [use gtk-doc to build documentation [[default=no]]]),, [enable_gtk_doc=no]) AC_MSG_CHECKING([whether to build gtk-doc documentation]) AC_MSG_RESULT($enable_gtk_doc) if test "x$enable_gtk_doc" = "xyes" && test "$have_gtk_doc" = "no"; then AC_MSG_ERROR([ You must have $gtk_doc_requires installed to build documentation for $PACKAGE_NAME. Please install gtk-doc or disable building the documentation by adding '--disable-gtk-doc' to '[$]0'.]) fi dnl don't check for glib if we build glib if test "x$PACKAGE_NAME" != "xglib"; then dnl don't fail if someone does not have glib PKG_CHECK_MODULES(GTKDOC_DEPS, glib-2.0 >= 2.10.0 gobject-2.0 >= 2.10.0,,[:]) fi dnl enable/disable output formats AC_ARG_ENABLE([gtk-doc-html], AS_HELP_STRING([--enable-gtk-doc-html], [build documentation in html format [[default=yes]]]),, [enable_gtk_doc_html=yes]) AC_ARG_ENABLE([gtk-doc-pdf], AS_HELP_STRING([--enable-gtk-doc-pdf], [build documentation in pdf format [[default=no]]]),, [enable_gtk_doc_pdf=no]) if test -z "$GTKDOC_MKPDF"; then enable_gtk_doc_pdf=no fi if test -z "$AM_DEFAULT_VERBOSITY"; then AM_DEFAULT_VERBOSITY=1 fi AC_SUBST([AM_DEFAULT_VERBOSITY]) AM_CONDITIONAL([HAVE_GTK_DOC], [test x$have_gtk_doc = xyes]) AM_CONDITIONAL([ENABLE_GTK_DOC], [test x$enable_gtk_doc = xyes]) AM_CONDITIONAL([GTK_DOC_BUILD_HTML], [test x$enable_gtk_doc_html = xyes]) AM_CONDITIONAL([GTK_DOC_BUILD_PDF], [test x$enable_gtk_doc_pdf = xyes]) AM_CONDITIONAL([GTK_DOC_USE_LIBTOOL], [test -n "$LIBTOOL"]) AM_CONDITIONAL([GTK_DOC_USE_REBASE], [test -n "$GTKDOC_REBASE"]) ]) libldm-libldm-0.2.5/src/000077500000000000000000000000001402606704000150105ustar00rootroot00000000000000libldm-libldm-0.2.5/src/Makefile.am000066400000000000000000000042551402606704000170520ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . AM_CFLAGS = -Wall -Werror -Wshadow -Wextra \ -Wno-unused-local-typedefs \ -Wno-unused-parameter libname = libldm-1.0.la lib_LTLIBRARIES = $(libname) include_HEADERS = ldm.h libldm_1_0_la_SOURCES = mbr.h mbr.c gpt.h gpt.c ldm.h ldm.c libldm_1_0_la_CFLAGS = $(AM_CFLAGS) $(GOBJECT_CFLAGS) $(ZLIB_CFLAGS) $(UUID_CFLAGS) $(DEVMAPPER_CFLAGS) libldm_1_0_la_LIBADD = $(ZLIB_LIBS) $(UUID_LIBS) $(GOBJECT_LIBS) $(DEVMAPPER_LIBS) bin_PROGRAMS = ldmtool ldmtool_CFLAGS = $(AM_CFLAGS) $(GOBJECT_CFLAGS) $(JSON_CFLAGS) \ $(GIO_UNIX_CFLAGS) ldmtool_LDADD = -lreadline $(builddir)/$(libname) $(GOBJECT_LIBS) \ $(JSON_LIBS) $(GIO_UNIX_LIBS) # GObject introspection fails. This seems to be because g-ir-scanner incorrectly # guesses the symbol prefix as 'l_dm', although explicitly passing in the # correct prefix causes it not to recognise any of the objects name symbols. I'm # fairly sure this is going to require a fix in g-ir-scanner. #include $(INTROSPECTION_MAKEFILE) # #INTROSPECTION_GIRS = LDM-1.0.gir #INTROSPECTION_SCANNER_ARGS = --add-include-path=$(srcdir) --warn-all #INTROSPECTION_COMPILER_ARGS = --includedir=$(srcdir) # #introspection_sources = ldm.h ldm.c # #LDM-1.0.gir: $(libname) #LDM_1_0_gir_INCLUDES = GObject-2.0 #LDM_1_0_gir_CFLAGS = $(INCLUDES) -I$(srcdir) #LDM_1_0_gir_LIBS = $(libname) #LDM_1_0_gir_FILES = $(patsubst %,$(srcdir)/%,$(introspection_sources)) # #girdir = $(datadir)/gir-1.0 #gir_DATA = $(INTROSPECTION_GIRS) # #typelibdir = $(libdir)/girepository-1.0 #typelib_DATA = $(INTROSPECTION_GIRS:.gir=.typelib) libldm-libldm-0.2.5/src/gpt.c000066400000000000000000000136321402606704000157530ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #include #include #include #include #include #include #include #include #include #include #include #include "gpt.h" struct _gpt_head { char magic[8]; uint32_t revision; uint32_t size; } __attribute__((__packed__)); struct _gpt { struct _gpt_head head; uint32_t header_crc; char padding1[4]; uint64_t current_header_lba; uint64_t backup_header_lba; uint64_t first_usable_lba; uint64_t last_usable_lba; uuid_t disk_guid; uint64_t pte_array_start_lba; uint32_t pte_array_len; uint32_t pte_size; uint32_t pte_array_crc; char padding2[]; } __attribute__((__packed__)); struct _gpt_part { uuid_t type; uuid_t guid; uint64_t first_lba; uint64_t last_lba; uint64_t flags; char name[72]; } __attribute__((__packed__)); struct _gpt_handle { int fd; struct _gpt *gpt; char *pte_array; iconv_t cd; }; int gpt_open_secsize(int fd, const size_t secsize, gpt_handle_t **h) { int err = 0; const off_t gpt_start = secsize; struct _gpt_head head; size_t read = 0; while (read < sizeof(head)) { ssize_t in = pread(fd, &head + read, sizeof(head) - read, read + gpt_start); if (in == 0) return -GPT_ERROR_INVALID; if (in == -1) return -GPT_ERROR_READ; read += in; } if (memcmp(head.magic, "EFI PART", 8) != 0) return -GPT_ERROR_INVALID; /* Check the header size. Don't believe anything greater than 4k. */ uint32_t header_size = le32toh(head.size); if (header_size > 4*1024) return -GPT_ERROR_INVALID; *h = malloc(sizeof(**h)); if (*h == NULL) abort(); (*h)->gpt = NULL; (*h)->pte_array = NULL; (*h)->cd = iconv_open("UTF-8", "UTF-16LE"); (*h)->gpt = malloc(header_size); if ((*h)->gpt == NULL) abort(); (*h)->fd = fd; struct _gpt *_gpt = (*h)->gpt; memcpy(_gpt, &head, sizeof(head)); while (read < le32toh(head.size)) { ssize_t in = pread(fd, (char *)(_gpt) + read, le32toh(head.size) - read, read + gpt_start); if (in == 0) { err = -GPT_ERROR_INVALID; goto error; } if (in == -1) { err = -GPT_ERROR_READ; goto error; } read += in; } uint32_t header_crc = _gpt->header_crc; _gpt->header_crc = 0; uint32_t crc = crc32(0L, Z_NULL, 0); crc = crc32(crc, (Bytef *)_gpt, _gpt->head.size); if (crc != header_crc) { err = -GPT_ERROR_INVALID; goto error; } uint32_t pte_array_len = le32toh(_gpt->pte_array_len); uint32_t pte_size = le32toh(_gpt->pte_size); /* Sanity check partition entries metadata */ if (pte_array_len > 1024 || pte_size > 1024) { err = -GPT_ERROR_INVALID; goto error; } const uint32_t pte_array_size = pte_array_len * pte_size; (*h)->pte_array = malloc(pte_array_size); if ((*h)->pte_array == NULL) abort(); const off_t pte_array_start = _gpt->pte_array_start_lba * secsize; read = 0; while (read < pte_array_size) { ssize_t in = pread(fd, (*h)->pte_array + read, pte_array_size - read, read + pte_array_start); if (in == 0) { err = -GPT_ERROR_INVALID; goto error; } if (in == -1) { err = -GPT_ERROR_READ; goto error; } read += in; } crc = crc32(0L, Z_NULL, 0); crc = crc32(crc, (Bytef *) (*h)->pte_array, pte_array_size); if (crc != _gpt->pte_array_crc) { err = -GPT_ERROR_INVALID; goto error; } return 0; error: if ((*h)->cd) iconv_close((*h)->cd); free((*h)->gpt); free((*h)->pte_array); free(*h); return err; } int gpt_open(int fd, gpt_handle_t **h) { int secsize; if (ioctl(fd, BLKSSZGET, &secsize) == -1) { secsize = 512; } return gpt_open_secsize(fd, secsize, h); } void gpt_close(gpt_handle_t *h) { iconv_close(h->cd); free(h->pte_array); free(h->gpt); free(h); } void gpt_get_header(gpt_handle_t *h, gpt_t *gpt) { struct _gpt *_gpt = h->gpt; gpt->first_usable_lba = le64toh(_gpt->first_usable_lba); gpt->last_usable_lba = le64toh(_gpt->last_usable_lba); gpt->pte_array_len = le32toh(_gpt->pte_array_len); gpt->pte_size = le32toh(_gpt->pte_size); memcpy(gpt->disk_guid, _gpt->disk_guid, sizeof(gpt->disk_guid)); } int gpt_get_pte(gpt_handle_t *h, uint32_t n, gpt_pte_t *part) { if (n >= le32toh(h->gpt->pte_array_len)) return -GPT_ERROR_INVALID_PART; struct _gpt_part *_part = (struct _gpt_part *) (h->pte_array + le32toh(h->gpt->pte_size) * n); memcpy(part->type, _part->type, sizeof(part->type)); memcpy(part->guid, _part->guid, sizeof(part->guid)); part->first_lba = le64toh(_part->first_lba); part->last_lba = le64toh(_part->last_lba); part->flags = le64toh(_part->flags); char *inbuf = _part->name; size_t in_rem = sizeof(_part->name); char *outbuf = part->name; size_t out_rem = sizeof(part->name); iconv(h->cd, &inbuf, &in_rem, &outbuf, &out_rem); return 0; } libldm-libldm-0.2.5/src/gpt.h000066400000000000000000000027161402606704000157610ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #include #include typedef enum { GPT_ERROR_OK, GPT_ERROR_INVALID, GPT_ERROR_READ, GPT_ERROR_INVALID_PART } gpt_error_t; typedef struct { uint64_t first_usable_lba; uint64_t last_usable_lba; uuid_t disk_guid; uint32_t pte_array_len; uint32_t pte_size; } gpt_t; typedef struct { uuid_t type; uuid_t guid; uint64_t first_lba; uint64_t last_lba; uint64_t flags; char name[72]; } gpt_pte_t; typedef struct _gpt_handle gpt_handle_t; int gpt_open(int fd, gpt_handle_t **h); int gpt_open_secsize(int fd, size_t secsize, gpt_handle_t **h); void gpt_close(gpt_handle_t *h); void gpt_get_header(gpt_handle_t *h, gpt_t *gpt); int gpt_get_pte(gpt_handle_t *h, uint32_t n, gpt_pte_t *part); libldm-libldm-0.2.5/src/ldm.c000066400000000000000000002730501402606704000157370ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "mbr.h" #include "gpt.h" #include "ldm.h" #define DM_UUID_PREFIX "LDM-" #define UUID_FMT "%02x%02x%02x%02x-%02x%02x-%02x%02x-" \ "%02x%02x-%02x%02x%02x%02x%02x%02x" #define UUID_VALS(uuid) (uuid)[0], (uuid)[1], (uuid)[2], (uuid)[3], \ (uuid)[4], (uuid)[5], (uuid)[6], (uuid)[7], \ (uuid)[8], (uuid)[9], (uuid)[10], (uuid)[11], \ (uuid)[12], (uuid)[13], (uuid)[14], (uuid)[15] /** * SECTION:ldm * @include: ldm.h */ /* * The layout here is mostly derived from: * http://hackipedia.org/Disk%20formats/Partition%20tables/Windows%20NT%20Logical%20Disk%20Manager/html,%20ldmdoc/index.html * * Note that the above reference describes a slightly older version of LDM, but * the fields it describes remain accurate. * * The principal difference from the above version is the addition of support * for LDM on GPT disks. */ /* Fixed structures * * These structures don't contain any variable-length fields, and can therefore * be accessed directly. */ struct _privhead { char magic[8]; // "PRIVHEAD" uint32_t unknown_sequence; uint16_t version_major; uint16_t version_minor; uint64_t unknown_timestamp; uint64_t unknown_number; uint64_t unknown_size1; uint64_t unknown_size2; char disk_guid[64]; char host_guid[64]; char disk_group_guid[64]; char disk_group_name[32]; uint16_t unknown1; char padding1[9]; uint64_t logical_disk_start; uint64_t logical_disk_size; uint64_t ldm_config_start; uint64_t ldm_config_size; uint64_t n_tocs; uint64_t toc_size; uint32_t n_configs; uint32_t n_logs; uint64_t config_size; uint64_t log_size; uint32_t disk_signature; /* Values below aren't set in my data */ char disk_set_guid[16]; char disk_set_guid_dup[16]; } __attribute__((__packed__)); struct _tocblock_bitmap { char name[8]; uint16_t flags1; uint64_t start; uint64_t size; // Relative to start of DB uint64_t flags2; } __attribute__((__packed__)); struct _tocblock { char magic[8]; // "TOCBLOCK" uint32_t seq1; char padding1[4]; uint32_t seq2; char padding2[16]; struct _tocblock_bitmap bitmap[2]; } __attribute__((__packed__)); struct _vmdb { char magic[4]; // "VMDB" uint32_t vblk_last; uint32_t vblk_size; uint32_t vblk_first_offset; uint16_t update_status; uint16_t version_major; uint16_t version_minor; char disk_group_name[31]; char disk_group_guid[64]; uint64_t committed_seq; uint64_t pending_seq; uint32_t n_committed_vblks_vol; uint32_t n_committed_vblks_comp; uint32_t n_committed_vblks_part; uint32_t n_committed_vblks_disk; char padding1[12]; uint32_t n_pending_vblks_vol; uint32_t n_pending_vblks_comp; uint32_t n_pending_vblks_part; uint32_t n_pending_vblks_disk; char padding2[12]; uint64_t last_accessed; } __attribute__((__packed__)); /* This is the header of every VBLK entry */ struct _vblk_head { char magic[4]; // "VBLK" uint32_t seq; uint32_t record_id; uint16_t entry; uint16_t entries_total; } __attribute__((__packed__)); /* This is the header of every VBLK record, which may span multiple VBLK * entries. I.e. if a VBLK record is split across 2 entries, only the first will * have this header immediately following the entry header. */ struct _vblk_rec_head { uint16_t status; uint8_t flags; uint8_t type; uint32_t size; } __attribute__((__packed__)); /* Array clearing functions */ static void _unref_object(gpointer const data) { g_object_unref(*(GObject **)data); } static void _free_pointer(gpointer const data) { g_free(*(gpointer *)data); } static void _free_gstring(gpointer const data) { g_string_free(*(GString **)data, TRUE); } /* GLIB error handling */ GQuark ldm_error_quark(void) { return g_quark_from_static_string("ldm"); } GType ldm_error_get_type(void) { static GType etype = 0; if (etype == 0) { static const GEnumValue values[] = { { LDM_ERROR_INTERNAL, "LDM_ERROR_INTERNAL", "internal" }, { LDM_ERROR_IO, "LDM_ERROR_IO", "io" }, { LDM_ERROR_NOT_LDM, "LDM_ERROR_NOT_LDM", "not_ldm" }, { LDM_ERROR_INVALID, "LDM_ERROR_INVALID", "invalid" }, { LDM_ERROR_INCONSISTENT, "LDM_ERROR_INCONSISTENT", "inconsistent" }, { LDM_ERROR_NOTSUPPORTED, "LDM_ERROR_NOTSUPPORTED", "notsupported" }, { LDM_ERROR_MISSING_DISK, "LDM_ERROR_MISSING_DISK", "missing-disk" }, { LDM_ERROR_EXTERNAL, "LDM_ERROR_EXTERNAL", "external" } }; etype = g_enum_register_static("LDMError", values); } return etype; } /* We catch log messages generated by device mapper with errno != 0 and store * them here */ static int _dm_err_last_level = 0; static const char *_dm_err_last_file = NULL; static int _dm_err_last_line = 0; static int _dm_err_last_errno = 0; static char *_dm_err_last_msg = NULL; static void _dm_log_fn(const int level, const char * const file, const int line, const int dm_errno, const char *f, ...) { if (dm_errno == 0) return; _dm_err_last_level = level; _dm_err_last_file = file; _dm_err_last_line = line; /* device-mapper doesn't set dm_errno usefully (it only seems to use * EUNCLASSIFIED), so we capture errno directly and cross our fingers */ _dm_err_last_errno = errno; if (_dm_err_last_msg) { free(_dm_err_last_msg); _dm_err_last_msg = NULL; } va_list ap; va_start(ap, f); if (vasprintf(&_dm_err_last_msg, f, ap) == -1) { g_error("vasprintf"); } va_end(ap); } /* Macros for exporting object properties */ #define EXPORT_PROP_STRING(object, klass, property) \ gchar * \ ldm_ ## object ## _get_ ## property(const klass * const o) \ { \ gpointer p = o->priv->property; \ if (p == NULL) return NULL; \ \ const size_t len = strlen(p) + 1; \ gchar * const r = g_malloc(len); \ memcpy(r, p, len); \ return r; \ } #define EXPORT_PROP_GUID(object, klass) \ gchar * \ ldm_ ## object ## _get_guid(const klass * const o) \ { \ gchar *r = g_malloc(37); \ uuid_unparse(o->priv->guid, r); \ return r; \ } #define EXPORT_PROP_SCALAR(object, klass, property, type) \ type \ ldm_ ## object ## _get_ ## property(const klass * const o) \ { \ return o->priv->property; \ } /* LDM */ struct _LDMPrivate { GArray *disk_groups; }; G_DEFINE_TYPE_WITH_PRIVATE(LDM, ldm, G_TYPE_OBJECT) static void ldm_dispose(GObject * const object) { LDM *ldm = LDM_CAST(object); if (ldm->priv->disk_groups) { g_array_unref(ldm->priv->disk_groups); ldm->priv->disk_groups = NULL; } /* Restore default logging function. */ dm_log_with_errno_init(NULL); } static void ldm_init(LDM * const o) { o->priv = ldm_get_instance_private(o); bzero(o->priv, sizeof(*o->priv)); /* Provide our logging function. */ dm_log_with_errno_init(_dm_log_fn); dm_set_name_mangling_mode(DM_STRING_MANGLING_AUTO); dm_set_uuid_prefix(DM_UUID_PREFIX); } static void ldm_class_init(LDMClass * const klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->dispose = ldm_dispose; } /* LDMDiskGroup */ struct _LDMDiskGroupPrivate { uuid_t guid; uint32_t id; char *name; uint64_t sequence; /* GObjects */ GArray *disks; GArray *parts; GArray *vols; /* We don't expose components, so they're no GObjects */ uint32_t n_comps; GArray *comps; }; G_DEFINE_TYPE_WITH_PRIVATE(LDMDiskGroup, ldm_disk_group, G_TYPE_OBJECT) enum { PROP_LDM_DISK_GROUP_PROP0, PROP_LDM_DISK_GROUP_GUID, PROP_LDM_DISK_GROUP_NAME }; static void ldm_disk_group_get_property(GObject * const o, const guint property_id, GValue * const value, GParamSpec * const pspec) { LDMDiskGroup * const dg = LDM_DISK_GROUP(o); LDMDiskGroupPrivate * const priv = dg->priv; switch (property_id) { case PROP_LDM_DISK_GROUP_GUID: { char guid_str[37]; uuid_unparse(priv->guid, guid_str); g_value_set_string(value, guid_str); } break; case PROP_LDM_DISK_GROUP_NAME: g_value_set_string(value, priv->name); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(o, property_id, pspec); } } EXPORT_PROP_STRING(disk_group, LDMDiskGroup, name) EXPORT_PROP_GUID(disk_group, LDMDiskGroup) static void ldm_disk_group_dispose(GObject * const object) { LDMDiskGroup *dg = LDM_DISK_GROUP(object); if (dg->priv->vols) { g_array_unref(dg->priv->vols); dg->priv->vols = NULL; } if (dg->priv->comps) { g_array_unref(dg->priv->comps); dg->priv->comps = NULL; } if (dg->priv->parts) { g_array_unref(dg->priv->parts); dg->priv->parts = NULL; } if (dg->priv->disks) { g_array_unref(dg->priv->disks); dg->priv->disks = NULL; } } static void ldm_disk_group_finalize(GObject * const object) { LDMDiskGroup *dg = LDM_DISK_GROUP(object); g_free(dg->priv->name); dg->priv->name = NULL; } static void ldm_disk_group_class_init(LDMDiskGroupClass * const klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->dispose = ldm_disk_group_dispose; object_class->finalize = ldm_disk_group_finalize; object_class->get_property = ldm_disk_group_get_property; /** * LDMDiskGroup:guid: * * A string representation of the disk group's GUID. */ g_object_class_install_property( object_class, PROP_LDM_DISK_GROUP_GUID, g_param_spec_string( "guid", "GUID", "A string representation of the disk group's GUID", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDiskGroup:name: * * The name of the disk group. */ g_object_class_install_property( object_class, PROP_LDM_DISK_GROUP_NAME, g_param_spec_string( "name", "Name", "The name of the disk group", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); } static void ldm_disk_group_init(LDMDiskGroup * const o) { o->priv = ldm_disk_group_get_instance_private(o); bzero(o->priv, sizeof(*o->priv)); } /* LDMVolumeType */ GType ldm_volume_type_get_type(void) { static GType etype = 0; if (etype == 0) { static const GEnumValue values[] = { { LDM_VOLUME_TYPE_SIMPLE, "LDM_VOLUME_TYPE_SIMPLE", "simple" }, { LDM_VOLUME_TYPE_SPANNED, "LDM_VOLUME_TYPE_SPANNED", "spanned" }, { LDM_VOLUME_TYPE_STRIPED, "LDM_VOLUME_TYPE_STRIPED", "striped" }, { LDM_VOLUME_TYPE_MIRRORED, "LDM_VOLUME_TYPE_MIRRORED", "mirrored" }, { LDM_VOLUME_TYPE_RAID5, "LDM_VOLUME_TYPE_RAID5", "RAID5" } }; etype = g_enum_register_static("LDMVolumeType", values); } return etype; } /* LDMVolume */ typedef enum { _VOLUME_TYPE_GEN = 0x3, _VOLUME_TYPE_RAID5 = 0x4 } _int_volume_type; struct _LDMVolumePrivate { guint32 id; gchar *name; uuid_t guid; gchar *dgname; guint64 size; guint8 part_type; guint8 flags; /* Not exposed: unclear what it means */ gchar *id1; /* Not exposed: unclear what it means */ gchar *id2; /* Not exposed: unclear what it means */ guint64 size2; /* Not exposed: unclear what it means */ gchar *hint; /* Derived */ LDMVolumeType type; GArray *parts; guint64 chunk_size; /* Only used during parsing */ _int_volume_type _int_type; guint32 _n_comps; guint32 _n_comps_i; }; G_DEFINE_TYPE_WITH_PRIVATE(LDMVolume, ldm_volume, G_TYPE_OBJECT) enum { PROP_LDM_VOLUME_PROP0, PROP_LDM_VOLUME_NAME, PROP_LDM_VOLUME_GUID, PROP_LDM_VOLUME_TYPE, PROP_LDM_VOLUME_SIZE, PROP_LDM_VOLUME_PART_TYPE, PROP_LDM_VOLUME_HINT, PROP_LDM_VOLUME_CHUNK_SIZE }; static void ldm_volume_get_property(GObject * const o, const guint property_id, GValue * const value, GParamSpec *pspec) { LDMVolume * const vol = LDM_VOLUME(o); LDMVolumePrivate * const priv = vol->priv; switch (property_id) { case PROP_LDM_VOLUME_NAME: g_value_set_string(value, priv->name); break; case PROP_LDM_VOLUME_GUID: { char guid_str[37]; uuid_unparse(priv->guid, guid_str); g_value_set_string(value, guid_str); } break; case PROP_LDM_VOLUME_TYPE: g_value_set_enum(value, priv->type); break; case PROP_LDM_VOLUME_SIZE: g_value_set_uint64(value, priv->size); break; case PROP_LDM_VOLUME_PART_TYPE: g_value_set_uint(value, priv->part_type); break; case PROP_LDM_VOLUME_HINT: g_value_set_string(value, priv->hint); break; case PROP_LDM_VOLUME_CHUNK_SIZE: g_value_set_uint64(value, priv->chunk_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(o, property_id, pspec); } } EXPORT_PROP_STRING(volume, LDMVolume, name) EXPORT_PROP_GUID(volume, LDMVolume) EXPORT_PROP_SCALAR(volume, LDMVolume, size, guint64) EXPORT_PROP_SCALAR(volume, LDMVolume, part_type, guint8) EXPORT_PROP_STRING(volume, LDMVolume, hint) EXPORT_PROP_SCALAR(volume, LDMVolume, chunk_size, guint64) /* Sigh... another conflict with glib's _get_type() */ LDMVolumeType ldm_volume_get_voltype(const LDMVolume * const o) { return o->priv->type; } static void ldm_volume_dispose(GObject * const object) { LDMVolume * const vol_o = LDM_VOLUME(object); LDMVolumePrivate * const vol = vol_o->priv; if (vol->parts) { g_array_unref(vol->parts); vol->parts = NULL; } } static void ldm_volume_finalize(GObject * const object) { LDMVolume * const vol_o = LDM_VOLUME(object); LDMVolumePrivate * const vol = vol_o->priv; g_free(vol->name); vol->name = NULL; g_free(vol->dgname); vol->dgname = NULL; g_free(vol->id1); vol->id1 = NULL; g_free(vol->id2); vol->id2 = NULL; g_free(vol->hint); vol->hint = NULL; } static void ldm_volume_class_init(LDMVolumeClass * const klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->dispose = ldm_volume_dispose; object_class->finalize = ldm_volume_finalize; object_class->get_property = ldm_volume_get_property; /** * LDMVolume:name: * * The volume's name. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_NAME, g_param_spec_string( "name", "Name", "The volume's name", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:guid: * * The GUID of the volume. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_GUID, g_param_spec_string( "guid", "GUID", "The GUID of the volume", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:type: * * The volume type: simple, spanned, striped, mirrored or raid5. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_TYPE, g_param_spec_enum( "type", "Type", "The volume type: simple, spanned, striped, " "mirrored or raid5", LDM_TYPE_VOLUME_TYPE, LDM_VOLUME_TYPE_SIMPLE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:size: * * The volume size in sectors. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_SIZE, g_param_spec_uint64( "size", "Size", "The volume size in sectors", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:part-type: * * A 1-byte type descriptor of the volume's contents. This descriptor has * the same meaning as for an MBR partition. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_PART_TYPE, g_param_spec_uint( "part-type", "Partition Type", "A 1-byte type descriptor of the " "volume's contents. This descriptor has the same meaning as for " "an MBR partition", 0, G_MAXUINT8, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:hint: * * A hint to Windows as to which drive letter to assign to this volume. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_HINT, g_param_spec_string( "hint", "Hint", "A hint to Windows as to which drive letter to " "assign to this volume", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMVolume:chunk-size: * * The chunk size of a striped or raided volume. */ g_object_class_install_property( object_class, PROP_LDM_VOLUME_CHUNK_SIZE, g_param_spec_uint64( "chunk-size", "Chunk Size", "The chunk size of a striped or raided volume", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); } static void ldm_volume_init(LDMVolume * const o) { o->priv = ldm_volume_get_instance_private(o); bzero(o->priv, sizeof(*o->priv)); /* We don't have a trivial way to initialize this array to the correct size * during parsing because we cut out components. We initialize it here and * allow it to grow dynamically. */ o->priv->parts = g_array_new(FALSE, FALSE, sizeof(LDMPartition *)); g_array_set_clear_func(o->priv->parts, _unref_object); } /* We don't expose components externally */ typedef enum { _COMPONENT_TYPE_STRIPED = 0x1, _COMPONENT_TYPE_SPANNED = 0x2, _COMPONENT_TYPE_RAID = 0x3 } _LDMComponentType; struct _LDMComponent { guint32 id; guint32 parent_id; _LDMComponentType type; uint32_t n_parts; GArray *parts; guint64 chunk_size; guint32 n_columns; }; static void _cleanup_comp(gpointer const data) { struct _LDMComponent * const comp = (struct _LDMComponent *) data; g_array_unref(comp->parts); } /* LDMPartition */ struct _LDMPartitionPrivate { guint32 id; guint32 parent_id; gchar *name; guint64 start; guint64 vol_offset; /* Not exposed: only used for sanity checking */ guint64 size; guint32 index; /* Not exposed directly: container array is sorted */ guint32 disk_id; LDMDisk *disk; }; G_DEFINE_TYPE_WITH_PRIVATE(LDMPartition, ldm_partition, G_TYPE_OBJECT) enum { PROP_LDM_PARTITION_PROP0, PROP_LDM_PARTITION_NAME, PROP_LDM_PARTITION_START, PROP_LDM_PARTITION_SIZE }; static void ldm_partition_get_property(GObject * const o, const guint property_id, GValue * const value, GParamSpec * const pspec) { LDMPartition * const part = LDM_PARTITION(o); LDMPartitionPrivate * const priv = part->priv; switch (property_id) { case PROP_LDM_PARTITION_NAME: g_value_set_string(value, priv->name); break; case PROP_LDM_PARTITION_START: g_value_set_uint64(value, priv->start); break; case PROP_LDM_PARTITION_SIZE: g_value_set_uint64(value, priv->size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(o, property_id, pspec); } } EXPORT_PROP_STRING(partition, LDMPartition, name) EXPORT_PROP_SCALAR(partition, LDMPartition, start, guint64) EXPORT_PROP_SCALAR(partition, LDMPartition, size, guint64) static void ldm_partition_dispose(GObject * const object) { LDMPartition * const part_o = LDM_PARTITION(object); LDMPartitionPrivate * const part = part_o->priv; if (part->disk) { g_object_unref(part->disk); part->disk = NULL; } } static void ldm_partition_finalize(GObject * const object) { LDMPartition * const part_o = LDM_PARTITION(object); LDMPartitionPrivate * const part = part_o->priv; g_free(part->name); part->name = NULL; } static void ldm_partition_class_init(LDMPartitionClass * const klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->dispose = ldm_partition_dispose; object_class->finalize = ldm_partition_finalize; object_class->get_property = ldm_partition_get_property; /** * LDMPartition:name: * * The name of the partition. */ g_object_class_install_property( object_class, PROP_LDM_PARTITION_NAME, g_param_spec_string( "name", "Name", "The name of the partition", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMPartition:start: * * The start sector of the partition. */ g_object_class_install_property( object_class, PROP_LDM_PARTITION_START, g_param_spec_uint64( "start", "Start", "The start sector of the partition", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMPartition:size: * * The size of the partition in sectors. */ g_object_class_install_property( object_class, PROP_LDM_PARTITION_SIZE, g_param_spec_uint64( "size", "Size", "The size of the partition in sectors", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); } static void ldm_partition_init(LDMPartition * const o) { o->priv = ldm_partition_get_instance_private(o); bzero(o->priv, sizeof(*o->priv)); } /* LDMDisk */ struct _LDMDiskPrivate { guint32 id; gchar *name; gchar *dgname; guint64 data_start; guint64 data_size; guint64 metadata_start; guint64 metadata_size; uuid_t guid; gchar *device; // NULL until device is found }; G_DEFINE_TYPE_WITH_PRIVATE(LDMDisk, ldm_disk, G_TYPE_OBJECT) enum { PROP_LDM_DISK_PROP0, PROP_LDM_DISK_NAME, PROP_LDM_DISK_GUID, PROP_LDM_DISK_DEVICE, PROP_LDM_DISK_DATA_START, PROP_LDM_DISK_DATA_SIZE, PROP_LDM_DISK_METADATA_START, PROP_LDM_DISK_METADATA_SIZE }; static void ldm_disk_get_property(GObject * const o, const guint property_id, GValue * const value, GParamSpec * const pspec) { const LDMDisk * const disk = LDM_DISK(o); const LDMDiskPrivate * const priv = disk->priv; switch (property_id) { case PROP_LDM_DISK_NAME: g_value_set_string(value, priv->name); break; case PROP_LDM_DISK_GUID: { char guid_str[37]; uuid_unparse(priv->guid, guid_str); g_value_set_string(value, guid_str); } break; case PROP_LDM_DISK_DEVICE: g_value_set_string(value, priv->device); break; case PROP_LDM_DISK_DATA_START: g_value_set_uint64(value, priv->data_start); break; case PROP_LDM_DISK_DATA_SIZE: g_value_set_uint64(value, priv->data_size); break; case PROP_LDM_DISK_METADATA_START: g_value_set_uint64(value, priv->metadata_start); break; case PROP_LDM_DISK_METADATA_SIZE: g_value_set_uint64(value, priv->metadata_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(o, property_id, pspec); } } EXPORT_PROP_STRING(disk, LDMDisk, name) EXPORT_PROP_GUID(disk, LDMDisk) EXPORT_PROP_STRING(disk, LDMDisk, device) EXPORT_PROP_SCALAR(disk, LDMDisk, data_start, guint64) EXPORT_PROP_SCALAR(disk, LDMDisk, data_size, guint64) EXPORT_PROP_SCALAR(disk, LDMDisk, metadata_start, guint64) EXPORT_PROP_SCALAR(disk, LDMDisk, metadata_size, guint64) static void ldm_disk_finalize(GObject * const object) { LDMDisk * const disk_o = LDM_DISK(object); LDMDiskPrivate * const disk = disk_o->priv; g_free(disk->name); disk->name = NULL; g_free(disk->dgname); disk->dgname = NULL; g_free(disk->device); disk->device = NULL; } static void ldm_disk_class_init(LDMDiskClass * const klass) { GObjectClass *object_class = G_OBJECT_CLASS(klass); object_class->finalize = ldm_disk_finalize; object_class->get_property = ldm_disk_get_property; /** * LDMDisk:name: * * The name of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_NAME, g_param_spec_string( "name", "Name", "The name of the disk", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:guid: * * The GUID of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_GUID, g_param_spec_string( "guid", "GUID", "The GUID of the disk", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:device: * * The underlying device of this disk. This may be NULL if the disk is * missing from the disk group. */ g_object_class_install_property( object_class, PROP_LDM_DISK_DEVICE, g_param_spec_string( "device", "Device", "The underlying device of this disk. This may " "be NULL if the disk is missing from the disk group", NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:data-start: * * The start sector of the data area of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_DATA_START, g_param_spec_uint64( "data-start", "Data Start", "The start sector of the data area of " "the disk", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:data-size: * * The size, in sectors, of the data area of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_DATA_SIZE, g_param_spec_uint64( "data-size", "Data Size", "The size, in sectors, of the data area " "of the disk", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:metadata-start: * * The start sector of the metadata area of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_METADATA_START, g_param_spec_uint64( "metadata-start", "Metadata Start", "The start sector of the " "metadata area of the disk", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); /** * LDMDisk:metadata-size: * * The size, in sectors, of the metadata area of the disk. */ g_object_class_install_property( object_class, PROP_LDM_DISK_METADATA_SIZE, g_param_spec_uint64( "metadata-size", "Metadata Size", "The size, in sectors, of the " "metadata area of the disk", 0, G_MAXUINT64, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS ) ); } static void ldm_disk_init(LDMDisk * const o) { o->priv = ldm_disk_get_instance_private(o); bzero(o->priv, sizeof(*o->priv)); } static gboolean _find_vmdb(const void * const config, const gchar * const path, const guint secsize, const struct _vmdb ** const vmdb, GError ** const err) { /* TOCBLOCK starts 2 sectors into config */ const struct _tocblock *tocblock = config + secsize * 2; if (memcmp(tocblock->magic, "TOCBLOCK", 8) != 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Didn't find TOCBLOCK at config offset %" PRIX64, UINT64_C(0x400)); return FALSE; } g_debug("TOCBLOCK: %s\n" " Sequence1: %" PRIu64 "\n" " Sequence2: %" PRIu64 "\n" " Bitmap: %s\n" " Flags1: %04" PRIo8 "\n" " Start: %" PRIu64 "\n" " Size: %" PRIu64 "\n" " Flags2: %016" PRIo64 "\n" " Bitmap: %s\n" " Flags1: %04" PRIo8 "\n" " Start: %" PRIu64 "\n" " Size: %" PRIu64 "\n" " Flags2: %016" PRIo64, path, (uint64_t) be64toh(tocblock->seq1), (uint64_t) be64toh(tocblock->seq2), tocblock->bitmap[0].name, be16toh(tocblock->bitmap[0].flags1), (uint64_t) be64toh(tocblock->bitmap[0].start), (uint64_t) be64toh(tocblock->bitmap[0].size), (uint64_t) be64toh(tocblock->bitmap[0].flags2), tocblock->bitmap[1].name, be16toh(tocblock->bitmap[1].flags1), (uint64_t) be64toh(tocblock->bitmap[1].start), (uint64_t) be64toh(tocblock->bitmap[1].size), (uint64_t) be64toh(tocblock->bitmap[1].flags2)); /* Find the start of the DB */ *vmdb = NULL; for (int i = 0; i < 2; i++) { const struct _tocblock_bitmap *bitmap = &tocblock->bitmap[i]; if (strcmp(bitmap->name, "config") == 0) { *vmdb = config + be64toh(tocblock->bitmap[i].start) * secsize; break; } } if (*vmdb == NULL) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "TOCBLOCK doesn't contain config bitmap"); return FALSE; } if (memcmp((*vmdb)->magic, "VMDB", 4) != 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Didn't find VMDB at config offset %lX", (unsigned long int)((void *) (*vmdb) - config)); return FALSE; } g_debug("VMDB: %s\n" " VBLK last: %" PRIu32 "\n" " VBLK size: %" PRIu32 "\n" " VBLK first offset: %" PRIu32 "\n" " Version major: %" PRIu16 "\n" " Version minor: %" PRIu16 "\n" " Disk group GUID: %s\n" " Committed sequence: %" PRIu64 "\n" " Pending sequence: %" PRIu64 "\n" " Committed volumes: %" PRIu32 "\n" " Committed components: %" PRIu32 "\n" " Committed partitions: %" PRIu32 "\n" " Committed disks: %" PRIu32 "\n" " Pending volumes: %" PRIu32 "\n" " Pending components: %" PRIu32 "\n" " Pending partitions: %" PRIu32 "\n" " Pending disks: %" PRIu32, path, be32toh((*vmdb)->vblk_last), be32toh((*vmdb)->vblk_size), be32toh((*vmdb)->vblk_first_offset), be16toh((*vmdb)->version_major), be16toh((*vmdb)->version_minor), (*vmdb)->disk_group_guid, (uint64_t) be64toh((*vmdb)->committed_seq), (uint64_t) be64toh((*vmdb)->pending_seq), be32toh((*vmdb)->n_committed_vblks_vol), be32toh((*vmdb)->n_committed_vblks_comp), be32toh((*vmdb)->n_committed_vblks_part), be32toh((*vmdb)->n_committed_vblks_disk), be32toh((*vmdb)->n_pending_vblks_vol), be32toh((*vmdb)->n_pending_vblks_comp), be32toh((*vmdb)->n_pending_vblks_part), be32toh((*vmdb)->n_pending_vblks_disk)); return TRUE; } static gboolean _read_config(const int fd, const gchar * const path, const guint secsize, const struct _privhead * const privhead, void ** const config, GError ** const err) { /* Sanity check ldm_config_start and ldm_config_size */ struct stat stat; if (fstat(fd, &stat) == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Unable to stat %s: %m", path); return FALSE; } uint64_t size = stat.st_size; if (S_ISBLK(stat.st_mode)) { if (ioctl(fd, BLKGETSIZE64, &size) == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Unable to get block device size for %s: %m", path); return FALSE; } } const uint64_t config_start = be64toh(privhead->ldm_config_start) * secsize; const uint64_t config_size = be64toh(privhead->ldm_config_size) * secsize; if (config_start > size) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "LDM config start (%" PRIX64") is outside file in %s", config_start, path); return FALSE; } if (config_start + config_size > size) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "LDM config end (%" PRIX64 ") is outside file in %s", config_start + config_size, path); return FALSE; } *config = g_malloc(config_size); size_t read = 0; while (read < config_size) { ssize_t in = pread(fd, *config + read, config_size - read, config_start + read); if (in == 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "%s contains invalid LDM metadata", path); goto error; } if (in == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Error reading from %s: %m", path); goto error; } read += in; } return TRUE; error: g_free(*config); *config = NULL; return FALSE; } static gboolean _read_privhead_off(const int fd, const gchar * const path, const uint64_t ph_start, struct _privhead * const privhead, GError **err) { size_t read = 0; while (read < sizeof(*privhead)) { ssize_t in = pread(fd, (char *) privhead + read, sizeof(*privhead) - read, ph_start + read); if (in == 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "%s contains invalid LDM metadata", path); return FALSE; } if (in == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Error reading from %s: %m", path); return FALSE; } read += in; } if (memcmp(privhead->magic, "PRIVHEAD", 8) != 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "PRIVHEAD not found at offset %" PRIX64, ph_start); return FALSE; } g_debug("PRIVHEAD: %s\n" " Version Major: %" PRIu16 "\n" " Version Minor: %" PRIu16 "\n" " Disk GUID: %s\n" " Disk Group GUID: %s\n" " Logical Disk Start: %" PRIu64 "\n" " Logical Disk Size: %" PRIu64 "\n" " LDM Config Start: %" PRIu64 "\n" " LDM Config Size: %" PRIu64, path, be16toh(privhead->version_major), be16toh(privhead->version_minor), privhead->disk_guid, privhead->disk_group_guid, (uint64_t) be64toh(privhead->logical_disk_start), (uint64_t) be64toh(privhead->logical_disk_size), (uint64_t) be64toh(privhead->ldm_config_start), (uint64_t) be64toh(privhead->ldm_config_size)); return TRUE; } static gboolean _read_privhead_mbr(const int fd, const gchar * const path, const guint secsize, struct _privhead * const privhead, GError ** const err) { g_debug("Device %s uses MBR", path); /* On an MBR disk, the first PRIVHEAD is in sector 6 */ return _read_privhead_off(fd, path, secsize * 6, privhead, err); } void _map_gpt_error(const int e, const gchar * const path, GError ** const err) { switch (-e) { case GPT_ERROR_INVALID: g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "%s contains an invalid GPT header", path); break; case GPT_ERROR_READ: g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Error reading from %s: %m", path); break; case GPT_ERROR_INVALID_PART: g_error("Request for invalid GPT partition"); default: g_error("Unhandled GPT return value: %i\n", e); } } static gboolean _read_privhead_gpt(const int fd, const gchar * const path, const guint secsize, struct _privhead * const privhead, GError ** const err) { g_debug("Device %s uses GPT", path); int r; gpt_handle_t *h; r = gpt_open_secsize(fd, secsize, &h); if (r < 0) { _map_gpt_error(r, path, err); return FALSE; } gpt_t gpt; gpt_get_header(h, &gpt); static const uuid_t LDM_METADATA = { 0xAA,0xC8,0x08,0x58, 0x8F,0x7E, 0xE0,0x42, 0x85,0xD2, 0xE1,0xE9,0x04,0x34,0xCF,0xB3 }; for (uint32_t i = 0; i < gpt.pte_array_len; i++) { gpt_pte_t pte; r = gpt_get_pte(h, i, &pte); if (r < 0) { _map_gpt_error(r, path, err); gpt_close(h); return FALSE; } if (uuid_compare(pte.type, LDM_METADATA) == 0) { /* PRIVHEAD is in the last LBA of the LDM metadata partition */ gpt_close(h); return _read_privhead_off(fd, path, pte.last_lba * secsize, privhead, err); } } g_set_error(err, LDM_ERROR, LDM_ERROR_NOT_LDM, "%s does not contain LDM metadata", path); return FALSE; } static gboolean _read_privhead(const int fd, const gchar * const path, const guint secsize, struct _privhead * const privhead, GError ** const err) { // Whether the disk is MBR or GPT, we expect to find an MBR at the beginning mbr_t mbr; int r = mbr_read(fd, &mbr); if (r < 0) { switch (-r) { case MBR_ERROR_INVALID: g_set_error(err, LDM_ERROR, LDM_ERROR_NOT_LDM, "Didn't detect a partition table"); return FALSE; case MBR_ERROR_READ: g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Error reading from %s: %m", path); return FALSE; default: g_error("Unhandled return value from mbr_read: %i", r); } } switch (mbr.part[0].type) { case MBR_PART_WINDOWS_LDM: return _read_privhead_mbr(fd, path, secsize, privhead, err); case MBR_PART_EFI_PROTECTIVE: return _read_privhead_gpt(fd, path, secsize, privhead, err); default: g_set_error(err, LDM_ERROR, LDM_ERROR_NOT_LDM, "%s does not contain LDM metadata", path); return FALSE; } } #define PARSE_VAR_INT(func_name, out_type) \ static gboolean \ func_name(const guint8 ** const var, out_type * const out, \ const gchar * const field, const gchar * const type, \ GError ** const err) \ { \ guint8 i = **var; (*var)++; \ if (i > sizeof(*out)) { \ g_set_error(err, LDM_ERROR, LDM_ERROR_INTERNAL, \ "Found %hhu byte integer for %s:%s", i, field, type); \ return FALSE; \ } \ \ *out = 0; \ for(;i > 0; i--) { \ *out <<= 8; \ *out += **var; (*var)++; \ } \ \ return TRUE; \ } PARSE_VAR_INT(_parse_var_int32, uint32_t) PARSE_VAR_INT(_parse_var_int64, uint64_t) static gchar * _parse_var_string(const guint8 ** const var) { guint8 len = **var; (*var)++; gchar *ret = g_malloc(len + 1); memcpy(ret, *var, len); (*var) += len; ret[len] = '\0'; return ret; } static void _parse_var_skip(const guint8 ** const var) { guint8 len = **var; (*var)++; (*var) += len; } static gboolean _parse_vblk_vol(const guint8 revision, const guint16 flags, const guint8 * vblk, LDMVolumePrivate * const vol, GError ** const err) { if (revision != 5) { g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported volume VBLK revision %hhu", revision); return FALSE; } if (!_parse_var_int32(&vblk, &vol->id, "id", "volume", err)) return FALSE; vol->name = _parse_var_string(&vblk); /* Volume type: 'gen' or 'raid5'. We parse this elsewhere */ _parse_var_skip(&vblk); /* Unknown. N.B. Documentation lists this as a single zero, but I have * observed it to have the variable length string value: '8000000000000000' */ _parse_var_skip(&vblk); /* Volume state */ vblk += 14; vol->_int_type = *(uint8_t *)vblk; vblk += 1; switch(vol->_int_type) { case _VOLUME_TYPE_GEN: case _VOLUME_TYPE_RAID5: break; default: g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported volume VBLK type %u", vol->_int_type); return FALSE; } /* Unknown */ vblk += 1; /* Volume number */ vblk += 1; /* Zeroes */ vblk += 3; /* Flags */ vol->flags = *(uint8_t *)vblk; vblk += 1; if (!_parse_var_int32(&vblk, &vol->_n_comps, "n_children", "volume", err)) return FALSE; /* Commit id */ vblk += 8; /* Id? */ vblk += 8; if (!_parse_var_int64(&vblk, &vol->size, "size", "volume", err)) return FALSE; /* Zeroes */ vblk += 4; vol->part_type = *((uint8_t *)vblk); vblk++; /* Volume GUID */ memcpy(&vol->guid, vblk, 16); vblk += 16; if (flags & 0x08) vol->id1 = _parse_var_string(&vblk); if (flags & 0x20) vol->id2 = _parse_var_string(&vblk); if (flags & 0x80 && !_parse_var_int64(&vblk, &vol->size2, "size2", "volume", err)) return FALSE; if (flags & 0x02) vol->hint = _parse_var_string(&vblk); g_debug("Volume: %s\n" " ID: %" PRIu32 "\n" " Type: %" PRIi32 "\n" " Flags: %" PRIu8 "\n" " Children: %" PRIu32 "\n" " Size: %" PRIu64 "\n" " Partition Type: %" PRIu8 "\n" " ID1: %s\n" " ID2: %s\n" " Size2: %" PRIu64 "\n" " Hint: %s", vol->name, vol->id, vol->_int_type, vol->flags, vol->_n_comps, vol->size, vol->part_type, vol->id1, vol->id2, vol->size2, vol->hint); return TRUE; } static gboolean _parse_vblk_comp(const guint8 revision, const guint16 flags, const guint8 *vblk, struct _LDMComponent * const comp, GError ** const err) { if (revision != 3) { g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported component VBLK revision %hhu", revision); return FALSE; } if (!_parse_var_int32(&vblk, &comp->id, "id", "volume", err)) return FALSE; /* Name */ _parse_var_skip(&vblk); /* Volume state */ _parse_var_skip(&vblk); comp->type = *((uint8_t *) vblk); vblk++; switch (comp->type) { case _COMPONENT_TYPE_STRIPED: case _COMPONENT_TYPE_SPANNED: case _COMPONENT_TYPE_RAID: break; default: g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Component VBLK OID=%u has unsupported type %u", comp->id, comp->type); return FALSE; } /* Zeroes */ vblk += 4; if (!_parse_var_int32(&vblk, &comp->n_parts, "n_parts", "component", err)) return FALSE; comp->parts = g_array_sized_new(FALSE, FALSE, sizeof(LDMPartition *), comp->n_parts); /* All members of the component's partition array will be passed to the * parent volume's partition array after initial parsing. We don't unref its * objects on cleanup, which makes it cleaner to bulk-transfer them. */ /* Log Commit ID */ vblk += 8; /* Zeroes */ vblk += 8; if (!_parse_var_int32(&vblk, &comp->parent_id, "parent_id", "component", err)) return FALSE; /* Zeroes */ vblk += 1; if (flags & 0x10) { if (!_parse_var_int64(&vblk, &comp->chunk_size, "chunk_size", "component", err)) return FALSE; if (!_parse_var_int32(&vblk, &comp->n_columns, "n_columns", "component", err)) return FALSE; } g_debug("Component:\n" " ID: %" PRIu32 "\n" " Parent ID: %" PRIu32 "\n" " Type: %" PRIu32 "\n" " Parts: %" PRIu32 "\n" " Chunk Size: %" PRIu64 "\n" " Columns: %" PRIu32, comp->id, comp->parent_id, comp->type, comp->n_parts, comp->chunk_size, comp->n_columns); return TRUE; } static gboolean _parse_vblk_part(const guint8 revision, const guint16 flags, const guint8 *vblk, LDMPartitionPrivate * const part, GError ** const err) { if (revision != 3) { g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported partition VBLK revision %hhu", revision); return FALSE; } if (!_parse_var_int32(&vblk, &part->id, "id", "volume", err)) return FALSE; part->name = _parse_var_string(&vblk); /* Zeroes */ vblk += 4; /* Log Commit ID */ vblk += 8; part->start = be64toh(*(uint64_t *)vblk); vblk += 8; part->vol_offset = be64toh(*(uint64_t *)vblk); vblk += 8; if (!_parse_var_int64(&vblk, &part->size, "size", "partition", err)) return FALSE; if (!_parse_var_int32(&vblk, &part->parent_id, "parent_id", "partition", err)) return FALSE; if (!_parse_var_int32(&vblk, &part->disk_id, "disk_id", "partition", err)) return FALSE; if (flags & 0x08) { if (!_parse_var_int32(&vblk, &part->index, "index", "partition", err)) return FALSE; } g_debug("Partition: %s\n" " ID: %" PRIu32 "\n" " Parent ID: %" PRIu32 "\n" " Disk ID: %" PRIu32 "\n" " Index: %" PRIu32 "\n" " Start: %" PRIu64 "\n" " Vol Offset: %" PRIu64 "\n" " Size: %" PRIu64, part->name, part->id, part->parent_id, part->disk_id, part->index, part->start, part->vol_offset, part->size); return TRUE; } static gboolean _parse_vblk_disk(const guint8 revision, const guint16 flags, const guint8 *vblk, LDMDiskPrivate * const disk, GError ** const err) { if (!_parse_var_int32(&vblk, &disk->id, "id", "volume", err)) return FALSE; disk->name = _parse_var_string(&vblk); if (revision == 3) { char *guid = _parse_var_string(&vblk); if (uuid_parse(guid, disk->guid) == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Disk %u has invalid guid: %s", disk->id, guid); g_free(guid); return FALSE; } g_free(guid); /* No need to parse rest of structure */ } else if (revision == 4) { memcpy(&disk->guid, vblk, 16); /* No need to parse rest of structure */ } else { g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported disk VBLK revision %hhu", revision); return FALSE; } g_debug("Disk: %s\n" " ID: %u\n" " GUID: " UUID_FMT, disk->name, disk->id, UUID_VALS(disk->guid)); return TRUE; } static gboolean _parse_vblk_disk_group(const guint8 revision, const guint16 flags, const guint8 *vblk, LDMDiskGroupPrivate * const dg, GError ** const err) { if (revision != 3 && revision != 4) { g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unsupported disk VBLK revision %hhu", revision); return FALSE; } if (!_parse_var_int32(&vblk, &dg->id, "id", "disk group", err)) return FALSE; dg->name = _parse_var_string(&vblk); /* No need to parse rest of structure */ g_debug("Disk Group: %s\n" " ID: %u", dg->name, dg->id); return TRUE; } struct _spanned_rec { uint32_t record_id; uint16_t entries_total; uint16_t entries_found; int offset; char data[]; }; static gboolean _parse_vblk(const void * data, LDMDiskGroup * const dg_o, GArray *comps, const gchar * const path, const int offset, GError ** const err) { LDMDiskGroupPrivate * const dg = dg_o->priv; const struct _vblk_rec_head * const rec_head = data; const guint8 type = rec_head->type & 0x0F; const guint8 revision = (rec_head->type & 0xF0) >> 4; data += sizeof(struct _vblk_rec_head); switch (type) { case 0x00: /* Blank VBLK */ break; case 0x01: { LDMVolume * const vol = LDM_VOLUME(g_object_new(LDM_TYPE_VOLUME, NULL)); g_array_append_val(dg->vols, vol); if (!_parse_vblk_vol(revision, rec_head->flags, data, vol->priv, err)) return FALSE; break; } case 0x02: { g_array_set_size(comps, comps->len + 1); struct _LDMComponent *comp = (struct _LDMComponent *) comps->data + comps->len - 1; if (!_parse_vblk_comp(revision, rec_head->flags, data, comp, err)) return FALSE; break; } case 0x03: { LDMPartition * const part = LDM_PARTITION(g_object_new(LDM_TYPE_PARTITION, NULL)); g_array_append_val(dg->parts, part); if (!_parse_vblk_part(revision, rec_head->flags, data, part->priv, err)) return FALSE; break; } case 0x04: { LDMDisk * const disk = LDM_DISK(g_object_new(LDM_TYPE_DISK, NULL)); g_array_append_val(dg->disks, disk); if (!_parse_vblk_disk(revision, rec_head->flags, data, disk->priv, err)) return FALSE; break; } case 0x05: { if (!_parse_vblk_disk_group(revision, rec_head->flags, data, dg, err)) return FALSE; break; } default: g_set_error(err, LDM_ERROR, LDM_ERROR_NOTSUPPORTED, "Unknown VBLK type %hhi in %s at config offset %X", type, path, offset); return FALSE; } return TRUE; } gint _cmp_component_parts(gconstpointer a, gconstpointer b) { const LDMPartition * const ao = LDM_PARTITION(*(LDMPartition **)a); const LDMPartition * const bo = LDM_PARTITION(*(LDMPartition **)b); if (ao->priv->index < bo->priv->index) return -1; if (ao->priv->index > bo->priv->index) return 1; return 0; } static gboolean _parse_vblks(const void * const config, const gchar * const path, const struct _vmdb * const vmdb, LDMDiskGroup * const dg_o, GError ** const err) { LDMDiskGroupPrivate * const dg = dg_o->priv; GArray *spanned = g_array_new(FALSE, FALSE, sizeof(gpointer)); g_array_set_clear_func(spanned, _free_pointer); dg->sequence = be64toh(vmdb->committed_seq); guint32 n_disks = be32toh(vmdb->n_committed_vblks_disk); guint32 n_parts = be32toh(vmdb->n_committed_vblks_part); guint32 n_vols = be32toh(vmdb->n_committed_vblks_vol); guint32 n_comps = be32toh(vmdb->n_committed_vblks_comp); dg->disks = g_array_sized_new(FALSE, FALSE, sizeof(LDMDisk *), n_disks); dg->parts = g_array_sized_new(FALSE, FALSE, sizeof(LDMPartition *), n_parts); dg->vols = g_array_sized_new(FALSE, FALSE, sizeof(LDMVolume *), n_vols); g_array_set_clear_func(dg->disks, _unref_object); g_array_set_clear_func(dg->parts, _unref_object); g_array_set_clear_func(dg->vols, _unref_object); GArray *comps = g_array_sized_new(FALSE, TRUE, sizeof(struct _LDMComponent), n_comps); g_array_set_clear_func(comps, _cleanup_comp); const guint16 vblk_size = be32toh(vmdb->vblk_size); const guint16 vblk_data_size = vblk_size - sizeof(struct _vblk_head); const void *vblk = (void *)vmdb + be32toh(vmdb->vblk_first_offset); for(;;) { const int offset = vblk - config; const struct _vblk_head * const head = vblk; if (memcmp(head->magic, "VBLK", 4) != 0) break; /* Sanity check the header */ if (be16toh(head->entries_total) > 0 && be16toh(head->entry) >= be16toh(head->entries_total)) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "VBLK entry %u has entry (%hu) > total entries (%hu)", be32toh(head->seq), be16toh(head->entry), be16toh(head->entries_total)); goto error; } vblk += sizeof(struct _vblk_head); /* Check for a spanned record */ if (be16toh(head->entries_total) > 1) { /* Look for an existing record */ gboolean found = FALSE; for (guint i = 0; i < spanned->len; i++) { struct _spanned_rec * const r = g_array_index(spanned, struct _spanned_rec *, i); if (r->record_id == head->record_id) { r->entries_found++; memcpy(&r->data[be16toh(head->entry) * vblk_data_size], vblk, vblk_data_size); found = TRUE; break; } } if (!found) { struct _spanned_rec * const r = g_malloc0(offsetof(struct _spanned_rec, data) + head->entries_total * vblk_data_size); g_array_append_val(spanned, r); r->record_id = head->record_id; r->entries_total = be16toh(head->entries_total); r->entries_found = 1; r->offset = offset; memcpy(&r->data[be16toh(head->entry) * vblk_data_size], vblk, vblk_data_size); } } else { if (!_parse_vblk(vblk, dg_o, comps, path, offset, err)) goto error; } vblk += vblk_data_size; } for (guint i = 0; i < spanned->len; i++) { struct _spanned_rec * const rec = g_array_index(spanned, struct _spanned_rec *, i); if (rec->entries_found != rec->entries_total) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Expected to find %hu entries for record %u, but " "found %hu", rec->entries_total, rec->record_id, rec->entries_found); goto error; } if (!_parse_vblk(rec->data, dg_o, comps, path, rec->offset, err)) goto error; } g_array_unref(spanned); spanned = NULL; if (dg->disks->len != n_disks) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Expected %u disk VBLKs, but found %u", n_disks, dg->disks->len); goto error; } if (comps->len != n_comps) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Expected %u component VBLKs, but found %u", n_comps, comps->len); goto error; } if (dg->parts->len != n_parts) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Expected %u partition VBLKs, but found %u", n_parts, dg->parts->len); goto error; } if (dg->vols->len != n_vols) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Expected %u volume VBLKs, but found %u", n_vols, dg->vols->len); goto error; } for (guint32 i = 0; i < n_parts; i++) { LDMPartition * const part_o = g_array_index(dg->parts, LDMPartition *, i); LDMPartitionPrivate * const part = part_o->priv; /* Look for the underlying disk for this partition */ for (guint32 j = 0; j < n_disks; j++) { LDMDisk * const disk_o = g_array_index(dg->disks, LDMDisk *, j); LDMDiskPrivate * const disk = disk_o->priv; if (disk->id == part->disk_id) { part->disk = disk_o; g_object_ref(disk_o); break; } } if (part->disk == NULL) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Partition %u references unknown disk %u", part->id, part->disk_id); goto error; } /* Look for the parent component */ gboolean parent_found = FALSE; for (guint j = 0; j < comps->len; j++) { struct _LDMComponent * const comp = (struct _LDMComponent *)comps->data + j; if (comp->id == part->parent_id) { g_array_append_val(comp->parts, part_o); g_object_ref(part_o); parent_found = TRUE; break; } } if (!parent_found) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Didn't find parent component %u for partition %u", part->parent_id, part->id); goto error; } } for (guint32 i = 0; i < n_comps; i++) { struct _LDMComponent * const comp = (struct _LDMComponent *)comps->data + i; if (comp->parts->len != comp->n_parts) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Component %u expected %u partitions, but found %u", comp->id, comp->n_parts, comp->parts->len); goto error; } if (comp->n_columns > 0 && comp->n_columns != comp->parts->len) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Component %u n_columns %u doesn't match number of " "partitions %u", comp->id, comp->n_columns, comp->parts->len); goto error; } /* Sort partitions into index order */ g_array_sort(comp->parts, _cmp_component_parts); gboolean parent_found = FALSE; for (guint32 j = 0; j < n_vols; j++) { LDMVolume * const vol_o = g_array_index(dg->vols, LDMVolume *, j); LDMVolumePrivate * const vol = vol_o->priv; if (vol->id == comp->parent_id) { parent_found = TRUE; g_array_append_vals(vol->parts, comp->parts->data, comp->parts->len); vol->chunk_size = comp->chunk_size; vol->_n_comps_i++; switch (comp->type) { case _COMPONENT_TYPE_SPANNED: if (vol->_int_type != _VOLUME_TYPE_GEN) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Unsupported configuration: SPANNED " "component has parent volume with type %u", vol->_int_type); goto error; } if (vol->_n_comps > 1) { vol->type = LDM_VOLUME_TYPE_MIRRORED; } else if (comp->n_parts > 1) { vol->type = LDM_VOLUME_TYPE_SPANNED; } else { vol->type = LDM_VOLUME_TYPE_SIMPLE; } break; case _COMPONENT_TYPE_STRIPED: if (vol->_int_type != _VOLUME_TYPE_GEN) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Unsupported configuration: STRIPED " "component has parent volume with type %u", vol->_int_type); goto error; } if (vol->_n_comps != 1) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Unsupported configuration: STRIPED " "component has parent volume with %u " "child components", vol->_n_comps); goto error; } vol->type = LDM_VOLUME_TYPE_STRIPED; break; case _COMPONENT_TYPE_RAID: if (vol->_int_type != _VOLUME_TYPE_RAID5) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Unsupported configuration: RAID " "component has parent volume with type %u", vol->_int_type); goto error; } if (vol->_n_comps != 1) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Unsupported configuration: RAID " "component has parent volume with %u " "child components", vol->_n_comps); goto error; } vol->type = LDM_VOLUME_TYPE_RAID5; break; default: /* Should be impossible */ g_error("Unexpected component type %u", comp->type); } break; } } if (!parent_found) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Didn't find parent volume %u for component %u", comp->parent_id, comp->id); goto error; } } for (guint32 i = 0; i < n_vols; i++) { LDMVolume * const vol_o = g_array_index(dg->vols, LDMVolume *, i); LDMVolumePrivate * const vol = vol_o->priv; if (vol->_n_comps_i != vol->_n_comps) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Volume %u expected %u components, but only found %u", vol->id, vol->_n_comps, vol->_n_comps_i); goto error; } vol->dgname = g_strdup(dg->name); } for (guint32 i = 0; i < n_disks; i++) { LDMDisk * const disk_o = g_array_index(dg->disks, LDMDisk *, i); LDMDiskPrivate * const disk = disk_o->priv; disk->dgname = g_strdup(dg->name); } g_array_unref(comps); return TRUE; error: if (spanned) g_array_unref(spanned); if (comps) g_array_unref(comps); return FALSE; } gboolean ldm_add(LDM * const o, const gchar * const path, GError ** const err) { const int fd = open(path, O_RDONLY); if (fd == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_IO, "Error opening %s for reading: %m", path); return FALSE; } int secsize; if (ioctl(fd, BLKSSZGET, &secsize) == -1) { g_warning("Unable to determine sector size of %s. Assuming 512 byte " "sectors", path); secsize = 512; } return ldm_add_fd(o, fd, secsize, path, err); } gboolean ldm_add_fd(LDM * const o, const int fd, const guint secsize, const gchar * const path, GError ** const err) { GArray *disk_groups = o->priv->disk_groups; /* The GObject documentation states quite clearly that method calls on an * object which has been disposed should *not* result in an error. Seems * weird, but... */ if (!disk_groups) return TRUE; void *config = NULL; struct _privhead privhead; if (!_read_privhead(fd, path, secsize, &privhead, err)) goto error; if (!_read_config(fd, path, secsize, &privhead, &config, err)) goto error; const struct _vmdb *vmdb; if (!_find_vmdb(config, path, secsize, &vmdb, err)) goto error; uuid_t disk_guid; uuid_t disk_group_guid; if (uuid_parse(privhead.disk_guid, disk_guid) == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "PRIVHEAD contains invalid GUID for disk: %s", privhead.disk_guid); goto error; } if (uuid_parse(privhead.disk_group_guid, disk_group_guid) == -1) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "PRIVHEAD contains invalid GUID for disk group: %s", privhead.disk_group_guid); goto error; } LDMDiskGroup *dg_o = NULL; LDMDiskGroupPrivate *dg = NULL; for (guint i = 0; i < disk_groups->len; i++) { LDMDiskGroup *c = g_array_index(disk_groups, LDMDiskGroup *, i); if (uuid_compare(disk_group_guid, c->priv->guid) == 0) { dg_o = c; } } if (dg_o == NULL) { dg_o = LDM_DISK_GROUP(g_object_new(LDM_TYPE_DISK_GROUP, NULL)); dg = dg_o->priv; uuid_copy(dg_o->priv->guid, disk_group_guid); g_debug("Found new disk group: " UUID_FMT, UUID_VALS(disk_group_guid)); if (!_parse_vblks(config, path, vmdb, dg_o, err)) { g_object_unref(dg_o); dg_o = NULL; goto error; } g_array_append_val(disk_groups, dg_o); } else { dg = dg_o->priv; /* Check this disk is consistent with other disks */ uint64_t committed = be64toh(vmdb->committed_seq); if (committed != dg->sequence) { g_set_error(err, LDM_ERROR, LDM_ERROR_INCONSISTENT, "Members of disk group " UUID_FMT " are inconsistent: " "disk %s has committed sequence %" PRIu64 ", " "group has committed sequence %" PRIu64, UUID_VALS(disk_group_guid), path, committed, dg->sequence); goto error; } } /* Find the disk VBLK for the current disk and add additional information * from PRIVHEAD */ for (guint i = 0; i < dg->disks->len; i++) { LDMDisk * const disk_o = g_array_index(dg->disks, LDMDisk *, i); LDMDiskPrivate * const disk = disk_o->priv; if (uuid_compare(disk_guid, disk->guid) == 0) { disk->device = g_strdup(path); disk->data_start = be64toh(privhead.logical_disk_start); disk->data_size = be64toh(privhead.logical_disk_size); disk->metadata_start = be64toh(privhead.ldm_config_start); disk->metadata_size = be64toh(privhead.ldm_config_size); break; } } g_free(config); close(fd); return TRUE; error: g_free(config); close(fd); return FALSE; } LDM * ldm_new() { LDM *ldm = LDM_CAST(g_object_new(LDM_TYPE, NULL)); ldm->priv->disk_groups = g_array_sized_new(FALSE, FALSE, sizeof (LDMDiskGroup *), 1); g_array_set_clear_func(ldm->priv->disk_groups, _unref_object); return ldm; } GArray * ldm_get_disk_groups(LDM * const o) { if (o->priv->disk_groups) g_array_ref(o->priv->disk_groups); return o->priv->disk_groups; } GArray * ldm_disk_group_get_volumes(LDMDiskGroup * const o) { if (o->priv->vols) g_array_ref(o->priv->vols); return o->priv->vols; } GArray * ldm_disk_group_get_partitions(LDMDiskGroup * const o) { if (o->priv->parts) g_array_ref(o->priv->parts); return o->priv->parts; } GArray * ldm_disk_group_get_disks(LDMDiskGroup * const o) { if (o->priv->disks) g_array_ref(o->priv->disks); return o->priv->disks; } GArray * ldm_volume_get_partitions(LDMVolume * const o) { if (o->priv->parts) g_array_ref(o->priv->parts); return o->priv->parts; } LDMDisk * ldm_partition_get_disk(LDMPartition * const o) { if (o->priv->disk) g_object_ref(o->priv->disk); return o->priv->disk; } static GString * _dm_part_name(const LDMPartitionPrivate * const part) { const LDMDiskPrivate * const disk = part->disk->priv; GString * name = g_string_new(""); g_string_printf(name, "ldm_part_%s_%s", disk->dgname, part->name); return name; } static GString * _dm_part_uuid(const LDMPartitionPrivate * const part) { const LDMDiskPrivate * const disk = part->disk->priv; char ldm_disk_guid[37]; uuid_unparse_lower(disk->guid, ldm_disk_guid); GString * dm_uuid = g_string_new(""); g_string_printf(dm_uuid, "%s%s-%s", DM_UUID_PREFIX, part->name, ldm_disk_guid); return dm_uuid; } static GString * _dm_vol_name(const LDMVolumePrivate * const vol) { GString * r = g_string_new(""); g_string_printf(r, "ldm_vol_%s_%s", vol->dgname, vol->name); return r; } static GString * _dm_vol_uuid(const LDMVolumePrivate * const vol) { char ldm_vol_uuid[37]; uuid_unparse_lower(vol->guid, ldm_vol_uuid); GString * dm_uuid = g_string_new(""); g_string_printf(dm_uuid, "%s%s-%s", DM_UUID_PREFIX, vol->name, ldm_vol_uuid); return dm_uuid; } struct dm_target { guint64 start; guint64 size; const gchar * type; GString *params; }; static struct dm_tree * _dm_get_device_tree(GError **err) { struct dm_tree *tree; tree = dm_tree_create(); if (!tree) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_tree_create: %s", _dm_err_last_msg); return NULL; } struct dm_task *task; task = dm_task_create(DM_DEVICE_LIST); if (!task) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_task_create: %s", _dm_err_last_msg); goto error; } if (!dm_task_run(task)) { g_set_error_literal(err, LDM_ERROR, LDM_ERROR_EXTERNAL, _dm_err_last_msg); goto error; } struct dm_names *names; names = dm_task_get_names(task); if (!task) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_task_get_names: %s", _dm_err_last_msg); goto error; } if (names->dev != 0) { for (;;) { if (!dm_tree_add_dev(tree, major(names->dev), minor(names->dev))) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_tree_add_dev: %s", _dm_err_last_msg); goto error; } if (names->next == 0) break; names = (struct dm_names *)((char *)names + names->next); } } dm_task_destroy(task); return tree; error: if (tree) dm_tree_free(tree); if (task) dm_task_destroy(task); return NULL; } /* Returns TRUE if device with specified UUID is found or FALSE otherwise. * * Found device node is returned if dm_node is not NULL. In this case dm_tree * MUST not be NULL as well. And the caller is responsible to free device tree * by calling dm_tree_free function. */ gboolean _dm_find_tree_node_by_uuid(const gchar * const uuid, struct dm_tree_node ** dm_node, struct dm_tree ** dm_tree, GError ** const err) { gboolean r = FALSE; if (dm_node) { g_assert(dm_tree != NULL); *dm_node = NULL; } if (dm_tree) *dm_tree = NULL; struct dm_tree *tree = _dm_get_device_tree(err); if (tree) { struct dm_tree_node *node = dm_tree_find_node_by_uuid(tree, uuid); if (node) r = TRUE; if (dm_tree) *dm_tree = tree; else dm_tree_free(tree); if (dm_node) *dm_node = node; } return r; } gchar * _dm_get_device(const gchar * const uuid, GError ** const err) { GString *r = NULL; struct dm_tree_node *node = NULL; struct dm_tree *tree = NULL; struct dm_task *task = NULL; if (_dm_find_tree_node_by_uuid(uuid, &node, &tree, err)) { const struct dm_info *info = dm_tree_node_get_info(node); task = dm_task_create(DM_DEVICE_INFO); if (!task) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_task_create: %s", _dm_err_last_msg); goto error; } if (!dm_task_set_major(task, info->major)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_INFO: dm_task_set_major(%d) failed: %s", info->major, _dm_err_last_msg); goto error; } if (!dm_task_set_minor(task, info->minor)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_INFO: dm_task_set_major(%d) failed: %s", info->minor, _dm_err_last_msg); goto error; } if (!dm_task_run(task)) { g_set_error_literal(err, LDM_ERROR, LDM_ERROR_EXTERNAL, _dm_err_last_msg); goto error; } const char *dir = dm_dir(); char *mangled_name = dm_task_get_name_mangled(task); r = g_string_new(""); g_string_printf(r, "%s/%s", dir, mangled_name); dm_free(mangled_name); } error: if (tree) dm_tree_free(tree); if (task) dm_task_destroy(task); /* Really FALSE here - don't free but return the character data. */ return r ? g_string_free(r, FALSE) : NULL; } gboolean _dm_create(const gchar * const name, const gchar * const uuid, uint32_t udev_cookie, const guint n_targets, const struct dm_target * const targets, GString **mangled_name, GError ** const err) { gboolean r = TRUE; if (mangled_name) *mangled_name = NULL; struct dm_task * const task = dm_task_create(DM_DEVICE_CREATE); if (!task) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_task_create(DM_DEVICE_CREATE) failed: %s", _dm_err_last_msg); return FALSE; } if (!dm_task_set_name(task, name)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_CREATE: dm_task_set_name(%s) failed: %s", name, _dm_err_last_msg); r = FALSE; goto out; } if (!dm_task_set_uuid(task, uuid)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_CREATE: dm_task_set_uuid(%s) failed: %s", uuid, _dm_err_last_msg); r = FALSE; goto out; } for (guint i = 0; i < n_targets; i++) { const struct dm_target * const target = &targets[i]; if (!dm_task_add_target(task, target->start, target->size, target->type, target->params->str)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_CREATE: " "dm_task_add_target(%s, %" PRIu64 ", %" PRIu64 ", " "%s, %s) failed: %s", name, target->start, target->size, target->type, target->params->str, _dm_err_last_msg); r = FALSE; goto out; } } if (!dm_task_set_cookie(task, &udev_cookie, 0)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_CREATE: dm_task_set_cookie(%08X) failed: %s", udev_cookie, _dm_err_last_msg); r = FALSE; goto out; } if (!dm_task_run(task)) { g_set_error_literal(err, LDM_ERROR, LDM_ERROR_EXTERNAL, _dm_err_last_msg); r = FALSE; goto out; } if (mangled_name) { char *tmp = dm_task_get_name_mangled(task); *mangled_name = g_string_new(tmp); dm_free(tmp); } out: dm_task_destroy(task); return r; } gboolean _dm_remove(const gchar * const name, uint32_t udev_cookie, GError ** const err) { gboolean r = TRUE; struct dm_task * const task = dm_task_create(DM_DEVICE_REMOVE); if (!task) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_task_create(DM_DEVICE_REMOVE) failed: %s", _dm_err_last_msg); r = FALSE; goto out; } if (!dm_task_set_name(task, name)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_REMOVE: dm_task_set_name(%s) failed: %s", name, _dm_err_last_msg); r = FALSE; goto out; } if (udev_cookie && !dm_task_set_cookie(task, &udev_cookie, 0)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "DM_DEVICE_REMOVE: dm_task_set_cookie(%08X) failed: %s", udev_cookie, _dm_err_last_msg); r = FALSE; goto out; } /* If a remove operation fails, try again in case it was only opened * transiently. */ dm_task_retry_remove(task); if (!dm_task_run(task)) { if (_dm_err_last_errno == EBUSY) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "Device is still mounted"); } else { g_set_error_literal(err, LDM_ERROR, LDM_ERROR_EXTERNAL, _dm_err_last_msg); } r = FALSE; goto out; } out: dm_task_destroy(task); return r; } static GString * _dm_create_part(const LDMPartitionPrivate * const part, uint32_t cookie, GError ** const err) { const LDMDiskPrivate * const disk = part->disk->priv; if (!disk->device) { g_set_error(err, LDM_ERROR, LDM_ERROR_MISSING_DISK, "Disk %s required by partition %s is missing", disk->name, part->name); return NULL; } struct dm_target target; target.start = 0; target.size = part->size; target.type = "linear"; target.params = g_string_new(""); g_string_printf(target.params, "%s %" PRIu64, disk->device, disk->data_start + part->start); GString *name = _dm_part_name(part); GString *uuid = _dm_part_uuid(part); GString *mangled_name = NULL; if (!_dm_create(name->str, uuid->str, cookie, 1, &target, &mangled_name, err)) { mangled_name = NULL; } g_string_free(name, TRUE); g_string_free(uuid, TRUE); g_string_free(target.params, TRUE); return mangled_name; } /* Comparator function that allows for sorting LDMPartition objects by * vol_offset (as the partitions may not always be sorted in increasing * vol_offset order for spanned LDM partitions). */ static gint _cmp_component_vol_offset(gconstpointer a, gconstpointer b) { const LDMPartition * const ao = LDM_PARTITION(*(LDMPartition **)a); const LDMPartition * const bo = LDM_PARTITION(*(LDMPartition **)b); if (ao->priv->vol_offset < bo->priv->vol_offset) return -1; if (ao->priv->vol_offset > bo->priv->vol_offset) return 1; return 0; } static GString * _dm_create_spanned(const LDMVolumePrivate * const vol, GError ** const err) { GString *name = NULL; guint i = 0; struct dm_target *targets = g_malloc(sizeof(*targets) * vol->parts->len); /* Sort LDM partitions by vol_offset */ g_array_sort(vol->parts, _cmp_component_vol_offset); uint64_t pos = 0; for (; i < vol->parts->len; i++) { const LDMPartition * const part_o = g_array_index(vol->parts, const LDMPartition *, i); const LDMPartitionPrivate * const part = part_o->priv; const LDMDiskPrivate * const disk = part->disk->priv; if (!disk->device) { g_set_error(err, LDM_ERROR, LDM_ERROR_MISSING_DISK, "Disk %s required by spanned volume %s is missing", disk->name, vol->name); goto out; } /* Sanity check: current position from adding up sizes of partitions * should equal the volume offset of the partition */ if (pos != part->vol_offset) { g_set_error(err, LDM_ERROR, LDM_ERROR_INVALID, "Partition volume offset does not match sizes of " "preceding partitions"); goto out; } struct dm_target *target = &targets[i]; target->start = pos; target->size = part->size; target->type = "linear"; target->params = g_string_new(""); g_string_append_printf(target->params, "%s %" PRIu64, disk->device, disk->data_start + part->start); pos += part->size; } uint32_t cookie; if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } name = _dm_vol_name(vol); GString *uuid = _dm_vol_uuid(vol); if (!_dm_create(name->str, uuid->str, cookie, vol->parts->len, targets, NULL, err)) { g_string_free(name, TRUE); name = NULL; } g_string_free(uuid, TRUE); dm_udev_wait(cookie); out: for (; i > 0; i--) { struct dm_target *target = &targets[i-1]; g_string_free(target->params, TRUE); } g_free(targets); return name; } static GString * _dm_create_striped(const LDMVolumePrivate * const vol, GError ** const err) { GString *name = NULL; struct dm_target target; target.start = 0; target.size = vol->size; target.type = "striped"; target.params = g_string_new(""); g_string_printf(target.params, "%" PRIu32 " %" PRIu64, vol->parts->len, vol->chunk_size); for (guint i = 0; i < vol->parts->len; i++) { const LDMPartition * const part_o = g_array_index(vol->parts, const LDMPartition *, i); const LDMPartitionPrivate * const part = part_o->priv; const LDMDiskPrivate * const disk = part->disk->priv; if (!disk->device) { g_set_error(err, LDM_ERROR, LDM_ERROR_MISSING_DISK, "Disk %s required by striped volume %s is missing", disk->name, vol->name); goto out; } g_string_append_printf(target.params, " %s %" PRIu64, disk->device, disk->data_start + part->start); } uint32_t cookie; if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } name = _dm_vol_name(vol); GString *uuid = _dm_vol_uuid(vol); if (!_dm_create(name->str, uuid->str, cookie, 1, &target, NULL, err)) { g_string_free(name, TRUE); name = NULL; } g_string_free(uuid, TRUE); dm_udev_wait(cookie); out: g_string_free(target.params, TRUE); return name; } static GString * _dm_create_mirrored(const LDMVolumePrivate * const vol, GError ** const err) { GString *name = NULL; struct dm_target target; target.start = 0; target.size = vol->size; target.type = "raid"; target.params = g_string_new(""); g_string_printf(target.params, "raid1 1 128 %u", vol->parts->len); GArray * devices = g_array_new(FALSE, FALSE, sizeof(GString *)); g_array_set_clear_func(devices, _free_gstring); uint32_t cookie; if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } const char *dir = dm_dir(); int found = 0; for (guint i = 0; i < vol->parts->len; i++) { const LDMPartition * const part_o = g_array_index(vol->parts, const LDMPartition *, i); const LDMPartitionPrivate * const part = part_o->priv; GString * chunk = _dm_create_part(part, cookie, err); if (chunk == NULL) { if (err && (*err)->code == LDM_ERROR_MISSING_DISK) { g_warning("%s", (*err)->message); g_error_free(*err); *err = NULL; g_string_append(target.params, " - -"); continue; } else { goto out; } } found++; g_array_append_val(devices, chunk); g_string_append_printf(target.params, " - %s/%s", dir, chunk->str); } if (found == 0) { g_set_error(err, LDM_ERROR, LDM_ERROR_MISSING_DISK, "Mirrored volume is missing all partitions"); return FALSE; } /* Wait until all partitions have been created */ dm_udev_wait(cookie); if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } name = _dm_vol_name(vol); GString *uuid = _dm_vol_uuid(vol); if (!_dm_create(name->str, uuid->str, cookie, 1, &target, NULL, err)) { g_string_free(name, TRUE); name = NULL; } g_string_free(uuid, TRUE); dm_udev_wait(cookie); g_array_unref(devices); devices = NULL; out: if (devices) { GError *cleanup_err = NULL; for (int i = devices->len; i > 0; i--) { GString *device = g_array_index(devices, GString *, i - 1); if (!_dm_remove(device->str, 0, &cleanup_err)) { g_warning("%s", cleanup_err->message); g_error_free(cleanup_err); cleanup_err = NULL; } } g_array_unref(devices); devices = NULL; } g_string_free(target.params, TRUE); return name; } static GString * _dm_create_raid5(const LDMVolumePrivate * const vol, GError ** const err) { GString *name = NULL; GString *uuid = NULL; struct dm_target target; target.start = 0; target.size = vol->size; target.type = "raid"; target.params = g_string_new(""); g_string_append_printf(target.params, "raid5_ls 1 %" PRIu64 " %" PRIu32, vol->chunk_size, vol->parts->len); GArray * devices = g_array_new(FALSE, FALSE, sizeof(GString *)); g_array_set_clear_func(devices, _free_gstring); uint32_t cookie; if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } const char *dir = dm_dir(); guint n_found = 0; for (guint i = 0; i < vol->parts->len; i++) { const LDMPartition * const part_o = g_array_index(vol->parts, const LDMPartition *, i); const LDMPartitionPrivate * const part = part_o->priv; GString * chunk = _dm_create_part(part, cookie, err); if (chunk == NULL) { if (err && (*err)->code == LDM_ERROR_MISSING_DISK) { g_warning("%s", (*err)->message); g_error_free(*err); *err = NULL; g_string_append(target.params, " - -"); continue; } else { goto out; } } n_found++; g_array_append_val(devices, chunk); g_string_append_printf(target.params, " - %s/%s", dir, chunk->str); } if (n_found < vol->parts->len - 1) { g_set_error(err, LDM_ERROR, LDM_ERROR_MISSING_DISK, "RAID5 volume is missing more than 1 component"); goto out; } /* Wait until all partitions have been created */ dm_udev_wait(cookie); if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } name = _dm_vol_name(vol); uuid = _dm_vol_uuid(vol); if (!_dm_create(name->str, uuid->str, cookie, 1, &target, NULL, err)) { g_string_free(name, TRUE); name = NULL; g_string_free(uuid, TRUE); goto out; } g_string_free(uuid, TRUE); dm_udev_wait(cookie); g_array_unref(devices); devices = NULL; out: if (devices) { GError *cleanup_err = NULL; for (int i = devices->len; i > 0; i--) { GString *device = g_array_index(devices, GString *, i - 1); if (!_dm_remove(device->str, 0, &cleanup_err)) { g_warning("%s", cleanup_err->message); g_error_free(cleanup_err); cleanup_err = NULL; } } g_array_unref(devices); devices = NULL; } g_string_free(target.params, TRUE); return name; } GString * ldm_volume_dm_get_name(const LDMVolume * const o) { return _dm_vol_name(o->priv); } gchar * ldm_partition_dm_get_device(const LDMPartition * const o, GError ** const err) { GString *uuid = _dm_part_uuid(o->priv); gchar* r = _dm_get_device(uuid->str, err); g_string_free(uuid, TRUE); return r; } gchar * ldm_volume_dm_get_device(const LDMVolume * const o, GError ** const err) { GString *uuid = _dm_vol_uuid(o->priv); gchar* r = _dm_get_device(uuid->str, err); g_string_free(uuid, TRUE); return r; } gboolean ldm_volume_dm_create(const LDMVolume * const o, GString **created, GError ** const err) { if (created) *created = NULL; const LDMVolumePrivate * const vol = o->priv; /* Check if the device already exists */ GString *uuid = _dm_vol_uuid(vol); if (_dm_find_tree_node_by_uuid(uuid->str, NULL, NULL, err)) { g_string_free(uuid, TRUE); return TRUE; } g_string_free(uuid, TRUE); GString *name = NULL; switch (vol->type) { case LDM_VOLUME_TYPE_SIMPLE: case LDM_VOLUME_TYPE_SPANNED: name = _dm_create_spanned(vol, err); break; case LDM_VOLUME_TYPE_STRIPED: name = _dm_create_striped(vol, err); break; case LDM_VOLUME_TYPE_MIRRORED: name = _dm_create_mirrored(vol, err); break; case LDM_VOLUME_TYPE_RAID5: name = _dm_create_raid5(vol, err); break; default: /* Should be impossible */ g_error("Unexpected volume type: %u", vol->type); } gboolean r = name != NULL; if (created) *created = name; else if (name) g_string_free(name, TRUE); return r; } gboolean ldm_volume_dm_remove(const LDMVolume * const o, GString **removed, GError ** const err) { if (removed) *removed = NULL; const LDMVolumePrivate * const vol = o->priv; gboolean r = FALSE; struct dm_tree *tree = NULL; struct dm_tree_node *node = NULL; GString *uuid = _dm_vol_uuid(vol); gboolean found = _dm_find_tree_node_by_uuid(uuid->str, &node, &tree, err); g_string_free(uuid, TRUE); GString *name = NULL; if (found) { uint32_t cookie; if (!dm_udev_create_cookie(&cookie)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "dm_udev_create_cookie: %s", _dm_err_last_msg); goto out; } name = _dm_vol_name(vol); if (!_dm_remove(name->str, cookie, err)) { g_string_free(name, TRUE); name = NULL; goto out; } dm_tree_set_cookie(node, cookie); if (!dm_tree_deactivate_children(node, NULL, 0)) { g_set_error(err, LDM_ERROR, LDM_ERROR_EXTERNAL, "removing children: %s", _dm_err_last_msg); g_string_free(name, TRUE); name = NULL; goto out; } dm_udev_wait(cookie); } r = TRUE; out: if (tree) dm_tree_free(tree); if (removed) *removed = name; else if (name) g_string_free(name, TRUE); return r; } libldm-libldm-0.2.5/src/ldm.h000066400000000000000000000405321402606704000157410ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #ifndef LIBLDM_LDM_H__ #define LIBLDM_LDM_H__ #include G_BEGIN_DECLS #define LDM_ERROR ldm_error_quark() GQuark ldm_error_quark(void); /** * LDMError: * @LDM_ERROR_INTERNAL: An internal error * @LDM_ERROR_IO: There was an IO error accessing a device * @LDM_ERROR_NOT_LDM: The device is not part of an LDM disk group * @LDM_ERROR_INVALID: The LDM metadata is corrupt * @LDM_ERROR_INCONSISTENT: Detected two disks from the same disk group with * inconsistent metadata * @LDM_ERROR_NOTSUPPORTED: Unsupported LDM metadata * @LDM_ERROR_MISSING_DISK: A disk is missing from a disk group * @LDM_ERROR_EXTERNAL: An error reported by an external library */ typedef enum { LDM_ERROR_INTERNAL, LDM_ERROR_IO, LDM_ERROR_NOT_LDM, LDM_ERROR_INVALID, LDM_ERROR_INCONSISTENT, LDM_ERROR_NOTSUPPORTED, LDM_ERROR_MISSING_DISK, LDM_ERROR_EXTERNAL } LDMError; #define LDM_TYPE_ERROR (ldm_error_get_type()) GType ldm_error_get_type(void); /* LDM */ #define LDM_TYPE (ldm_get_type()) #define LDM_CAST(obj) (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), LDM_TYPE, LDM)) #define LDM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \ ((klass), LDM_TYPE, LDMClass)) #define IS_LDM(obj) (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), LDM_TYPE)) #define IS_LDM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \ ((klass), LDM_TYPE)) #define LDM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \ ((obj), LDM_TYPE, LDMClass)) typedef struct _LDMPrivate LDMPrivate; /** * LDM: * * An LDM metadata scanner */ typedef struct _LDM LDM; struct _LDM { GObject parent; LDMPrivate *priv; }; typedef struct { GObjectClass parent_class; } LDMClass; /* LDMDiskGroup */ #define LDM_TYPE_DISK_GROUP (ldm_disk_group_get_type()) #define LDM_DISK_GROUP(obj) (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), LDM_TYPE_DISK_GROUP, LDMDiskGroup)) #define LDM_DISK_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \ ((klass), LDM_TYPE_DISK_GROUP, LDMDiskGroupClass)) #define LDM_IS_DISK_GROUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), LDM_TYPE_DISK_GROUP)) #define LDM_IS_DISK_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \ ((klass), LDM_TYPE_DISK_GROUP)) #define LDM_DISK_GROUP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \ ((obj), LDM_TYPE_DISK_GROUP, LDMDiskGroupClass)) typedef struct _LDMDiskGroupPrivate LDMDiskGroupPrivate; /** * LDMDiskGroup: * * An LDM Disk Group */ typedef struct _LDMDiskGroup LDMDiskGroup; struct _LDMDiskGroup { GObject parent; LDMDiskGroupPrivate *priv; }; typedef struct { GObjectClass parent_class; } LDMDiskGroupClass; /* LDMVolumeType */ /** * LDMVolumeType: * @LDM_VOLUME_TYPE_SIMPLE: A simple volume * @LDM_VOLUME_TYPE_SPANNED: A spanned volume * @LDM_VOLUME_TYPE_STRIPED: A striped volume * @LDM_VOLUME_TYPE_MIRRORED: A mirrored volume * @LDM_VOLUME_TYPE_RAID5: A raid5 volume */ typedef enum { LDM_VOLUME_TYPE_SIMPLE, LDM_VOLUME_TYPE_SPANNED, LDM_VOLUME_TYPE_STRIPED, LDM_VOLUME_TYPE_MIRRORED, LDM_VOLUME_TYPE_RAID5 } LDMVolumeType; #define LDM_TYPE_VOLUME_TYPE (ldm_volume_type_get_type()) GType ldm_volume_type_get_type(void); /* LDMVolume */ #define LDM_TYPE_VOLUME (ldm_volume_get_type()) #define LDM_VOLUME(obj) (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), LDM_TYPE_VOLUME, LDMVolume)) #define LDM_VOLUME_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \ ((klass), LDM_TYPE_VOLUME, LDMVolumeClass)) #define LDM_IS_VOLUME(obj) (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), LDM_TYPE_VOLUME)) #define LDM_IS_VOLUME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \ ((klass), LDM_TYPE_VOLUME)) #define LDM_VOLUME_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \ ((obj), LDM_TYPE_VOLUME, LDMVolumeClass)) typedef struct _LDMVolumePrivate LDMVolumePrivate; /** * LDMVolume: * @parent: The parent #GObject * @priv: Private data * * An LDM Volume. */ typedef struct _LDMVolume LDMVolume; struct _LDMVolume { GObject parent; LDMVolumePrivate *priv; }; typedef struct { GObjectClass parent_class; } LDMVolumeClass; /* LDMPartition */ #define LDM_TYPE_PARTITION (ldm_partition_get_type()) #define LDM_PARTITION(obj) (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), LDM_TYPE_PARTITION, LDMPartition)) #define LDM_PARTITION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \ ((klass), LDM_TYPE_PARTITION, LDMPartitionClass)) #define LDM_IS_PARTITION(obj) (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), LDM_TYPE_PARTITION)) #define LDM_IS_PARTITION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \ ((klass), LDM_TYPE_PARTITION)) #define LDM_PARTITION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \ ((obj), LDM_TYPE_PARTITION, LDMPartitionClass)) typedef struct _LDMPartitionPrivate LDMPartitionPrivate; /** * LDMPartition: * @parent: The parent #GObject * @priv: Private data * * An LDM Parition. */ typedef struct _LDMPartition LDMPartition; struct _LDMPartition { GObject parent; LDMPartitionPrivate *priv; }; typedef struct { GObjectClass parent_class; } LDMPartitionClass; /* LDMDisk */ #define LDM_TYPE_DISK (ldm_disk_get_type()) #define LDM_DISK(obj) (G_TYPE_CHECK_INSTANCE_CAST \ ((obj), LDM_TYPE_DISK, LDMDisk)) #define LDM_DISK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST \ ((klass), LDM_TYPE_DISK, LDMDiskClass)) #define LDM_IS_DISK(obj) (G_TYPE_CHECK_INSTANCE_TYPE \ ((obj), LDM_TYPE_DISK)) #define LDM_IS_DISK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE \ ((klass), LDM_TYPE_DISK)) #define LDM_DISK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS \ ((obj), LDM_TYPE_DISK, LDMDiskClass)) typedef struct _LDMDiskPrivate LDMDiskPrivate; /** * LDMDisk: * @parent: The parent #GObject * @priv: Private data * * An LDM Disk. */ typedef struct _LDMDisk LDMDisk; struct _LDMDisk { GObject parent; LDMDiskPrivate *priv; }; typedef struct { GObjectClass parent_class; } LDMDiskClass; GType ldm_get_type(void); GType ldm_disk_group_get_type(void); /** * ldm_new: * * Instantiate a new LDM object. LDM scans devices and stores detected metadata. * * Returns: (transfer full): a new #LDM object */ LDM *ldm_new(); /** * ldm_add: * @o: An #LDM object * @path: The path of the device * @err: A #GError to receive any generated errors * * Scan device @path and add its metadata to LDM object @o. * * Returns: true on success, false on error */ gboolean ldm_add(LDM *o, const gchar *path, GError **err); /** * ldm_add_fd: * @o: An #LDM object * @fd: A file descriptor for reading from the device * @secsize: The size of a sector on the device * @path: The path of the device (for messages) * @err: A #GError to receive any generated errors * * Scan a device which has been previously opened for reading and add its * metadata to LDM object @o. * * Returns: true on success, false on error */ gboolean ldm_add_fd(LDM *o, int fd, guint secsize, const gchar *path, GError **err); /** * ldm_get_disk_groups: * @o: An #LDM object * * Get an array of discovered disk groups. * * Returns: (element-type LDMDiskGroup)(transfer container): * An array of disk groups */ GArray *ldm_get_disk_groups(LDM *o); /** * ldm_disk_group_get_volumes: * @o: An #LDMDiskGroup * * Get an array of all volumes in a disk group. * * Returns: (element-type LDMVolume)(transfer container): * An array of volumes */ GArray *ldm_disk_group_get_volumes(LDMDiskGroup *o); /** * ldm_disk_group_get_partitions: * @o: An #LDMPartition * * Get an array of all partitions in a disk group. * * Returns: (element-type LDMPartition)(transfer container): * An array of partitions */ GArray *ldm_disk_group_get_partitions(LDMDiskGroup *o); /** * ldm_disk_group_get_disks: * @o: An #LDMDiskGroup * * Get an array of all disks in a disk group. * * Returns: (element-type LDMDisk)(transfer container): * An array of disks */ GArray *ldm_disk_group_get_disks(LDMDiskGroup *o); /** * ldm_disk_group_get_name: * @o: An #LDMDiskGroup * * Get the Windows-assigned name of a disk group. * * Returns: (transfer full): The name */ gchar *ldm_disk_group_get_name(const LDMDiskGroup *o); /** * ldm_disk_group_get_guid: * @o: An #LDMDiskGroup * * Get the Windows-assigned GUID of a disk group. * * Returns: (transfer full): The string representation of the GUID */ gchar *ldm_disk_group_get_guid(const LDMDiskGroup *o); /** * ldm_volume_get_partitions: * @o: An #LDMVolume * * Get an array of all partitions in a volume. * * Returns: (element-type LDMPartition)(transfer container): * An array of partitions */ GArray *ldm_volume_get_partitions(LDMVolume *o); /** * ldm_volume_get_name: * @o: An #LDMVolume * * Get the Windows-assigned name of a volume. * * Returns: (transfer full): The name */ gchar *ldm_volume_get_name(const LDMVolume *o); /** * ldm_volume_get_guid: * @o: An #LDMVolume * * Get the Windows-assigned GUID of a volume. * * Returns: (transfer full): The string representation of the GUID */ gchar *ldm_volume_get_guid(const LDMVolume *o); /** * ldm_volume_get_voltype: * @o: An #LDMVolume * * Get the volume type. This can be: * - %LDM_VOLUME_TYPE_SIMPLE * - %LDM_VOLUME_TYPE_SPANNED * - %LDM_VOLUME_TYPE_STRIPED * - %LDM_VOLUME_TYPE_MIRRORED * - %LDM_VOLUME_TYPE_RAID5 * * Returns: The volume type */ LDMVolumeType ldm_volume_get_voltype(const LDMVolume *o); /** * ldm_volume_get_size: * @o: An #LDMVolume * * Get the volume size in sectors. * * Returns: The volume size in sectors */ guint64 ldm_volume_get_size(const LDMVolume *o); /** * ldm_volume_get_part_type: * @o: An #LDMVolume * * Get the 'partition type' of the volume. This is the same 8-bit value that is * used to describe partition types on an MBR disk. It is 0x07 for NTFS volumes. * * Returns: The partition type */ guint8 ldm_volume_get_part_type(const LDMVolume *o); /** * ldm_volume_get_hint: * @o: An #LDMVolume * * Get the volume mounting hint. This value specifies how Windows expects the * volume to be mounted. For a volume with an assigned drive letter, it might be * 'E:'. * * Returns: (transfer full): The mounting hint */ gchar *ldm_volume_get_hint(const LDMVolume *o); /** * ldm_volume_get_chunk_size: * @o: An #LDMVolume * * Get the chunk size, in sectors, used by striped and raid5 volumes. For other * volume types it will be 0. * * Returns: The chunk size in sectors */ guint64 ldm_volume_get_chunk_size(const LDMVolume *o); /** * ldm_volume_dm_get_name: * @o: An #LDMVolume * * Get the name of the device mapper device which will be created for this * volume. Note that returned name is unmangled. Device mapper will mangle * actual device name if it contains invalid characters. * * Returns: (transfer full): The device mapper name */ GString *ldm_volume_dm_get_name(const LDMVolume *o); /** * ldm_volume_dm_get_device: * @o: An #LDMVolume * @err: A #GError to receive any generated errors * * Get the host device mapper device which was created for this volume * (e.g. /dev/mapper/ldm_vol_Red-nzv8x6obywgDg0_Volume3). It is dynamic * runtime property and it will be NULL if device mapper device is absent. * * Returns: (transfer full): The host device mapper device if present, * or NULL otherwise */ gchar *ldm_volume_dm_get_device(const LDMVolume * const o, GError **err); /** * ldm_volume_dm_create: * @o: An #LDMVolume * @created: (out): The name of the created device, if any * @err: A #GError to receive any generated errors * * Create a device mapper device for a volume. If this function is called for * volume whose device already exists it will still return success. However, * @created will not be set. * * Returns: True if, following the call, the device exists. False if it doesn't. * @created will only be set if the call actually created the device. */ gboolean ldm_volume_dm_create(const LDMVolume *o, GString **created, GError **err); /** * ldm_volume_dm_remove: * @o: An #LDMVolume * @removed: (out): The name of the removed device, if any * @err: A #GError to receive any generated errors * * Remove a device mapper device for a volume. If this function is called for a * volume whose device does not already exist, it will still return success. * However, @removed will not be set. * * Returns: True if, following the call, the device does not exist. False if it * does. @removed will only be set if the call actually removed the * device. */ gboolean ldm_volume_dm_remove(const LDMVolume *o, GString **removed, GError **err); /** * ldm_partition_get_disk: * @o: An #LDMPartition * * Get the #LDMDisk underlying a partition. * * Returns: (transfer full): The underlying disk */ LDMDisk *ldm_partition_get_disk(LDMPartition *o); /** * ldm_partition_get_name: * @o: An #LDMPartition * * Get the Windows-assigned name of a partition. * * Returns: (transfer full): The name */ gchar *ldm_partition_get_name(const LDMPartition *o); /** * ldm_partition_get_start: * @o: An #LDMPartition * * Get the start sector of a disk, measured from the start of the underlying * disk. * * Returns: The start sector */ guint64 ldm_partition_get_start(const LDMPartition *o); /** * ldm_partition_get_size: * @o: An #LDMPartition * * Get the size of a partition in sectors. * * Returns: The size, in sectors */ guint64 ldm_partition_get_size(const LDMPartition *o); /** * ldm_partition_dm_get_device: * @o: An #LDMPartition * @err: A #GError to receive any generated errors * * Get the host device mapper device which was created for this partition * (e.g. /dev/mapper/ldm_part_Red-nzv8x6obywgDg0_Disk1-01). It is dynamic * runtime property and it will be NULL if device mapper device is absent. * * Returns: (transfer full): The host device mapper device if present, * or NULL otherwise */ gchar *ldm_partition_dm_get_device(const LDMPartition * const o, GError **err); /** * ldm_disk_get_name * @o: An #LDMDisk * * Get the Windows-assigned name of a disk. * * Returns: (transfer full): The name */ gchar *ldm_disk_get_name(const LDMDisk *o); /** * ldm_disk_get_guid: * @o: An #LDMDisk * * Get the Windows-assigned GUID of a disk. * * Returns: (transfer full): The string representation of the GUID */ gchar *ldm_disk_get_guid(const LDMDisk *o); /** * ldm_disk_get_device: * @o: An #LDMDisk * * Get the name of the host device (e.g. /dev/sda) of a disk. This will be NULL * if the disk has been identified from metadata on another disk, but has not * been discovered during scanning. * * Returns: The name of the host device, or NULL if the disk is missing */ gchar *ldm_disk_get_device(const LDMDisk *o); /** * ldm_disk_get_data_start: * @o: An #LDMDisk * * Get the start sector of the data portion of a disk. * * Returns: The start sector */ guint64 ldm_disk_get_data_start(const LDMDisk *o); /** * ldm_disk_get_data_size: * @o: An #LDMDisk * * Get the size, in sectors, of the data portion of a disk. * * Returns: The size in sectors */ guint64 ldm_disk_get_data_size(const LDMDisk *o); /** * ldm_disk_get_metadata_start: * @o: An #LDMDisk * * Get the start sector of the metadata portion of a disk. * * Returns: The start sector */ guint64 ldm_disk_get_metadata_start(const LDMDisk *o); /** * ldm_disk_get_metadata_size: * @o: An #LDMDisk * * Get the size, in sectors, of the metadata portion of a disk. * * Returns: The size in sectors */ guint64 ldm_disk_get_metadata_size(const LDMDisk *o); G_END_DECLS #endif /* LIBLDM_LDM_H__ */ libldm-libldm-0.2.5/src/ldmtool.c000066400000000000000000000576271402606704000166470ustar00rootroot00000000000000/* ldmread * Copyright 2012 Red Hat Inc. * * 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 * (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, see . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ldm.h" #define USAGE_SCAN \ " scan []" #define USAGE_SHOW \ " show diskgroup \n" \ " show volume \n" \ " show partition \n" \ " show disk " #define USAGE_CREATE \ " create all\n" \ " create volume " #define USAGE_REMOVE \ " remove all\n" \ " remove volume " #define USAGE_ALL USAGE_SCAN "\n" USAGE_SHOW "\n" USAGE_CREATE "\n" USAGE_REMOVE gboolean usage_show(void) { g_warning(USAGE_SHOW); return FALSE; } gboolean usage_create(void) { g_warning(USAGE_CREATE); return FALSE; } gboolean usage_remove(void) { g_warning(USAGE_REMOVE); return FALSE; } typedef gboolean (*_action_t) (LDM *ldm, gint argc, gchar **argv, JsonBuilder *jb); gboolean ldm_scan(LDM *ldm, gint argc, gchar **argv, JsonBuilder *jb); gboolean ldm_show(LDM *ldm, gint argc, gchar **argv, JsonBuilder *jb); gboolean ldm_create(LDM *ldm, gint argc, gchar **argv, JsonBuilder *jb); gboolean ldm_remove(LDM *ldm, gint argc, gchar **argv, JsonBuilder *jb); typedef struct { const char * name; const _action_t action; } _command_t; static const _command_t commands[] = { { "scan", ldm_scan }, { "show", ldm_show }, { "create", ldm_create }, { "remove", ldm_remove }, { NULL } }; gboolean do_command(LDM * const ldm, const int argc, char *argv[], gboolean *result, GOutputStream * const out, JsonGenerator * const jg, JsonBuilder * const jb) { const _command_t *i = commands; while (i->name) { if (g_strcmp0(i->name, argv[0]) == 0) { if ((i->action)(ldm, argc - 1, argv + 1, jb)) { GError *err = NULL; json_generator_set_root(jg, json_builder_get_root(jb)); if (!json_generator_to_stream(jg, out, NULL, &err)) { g_warning("Error writing JSON output: %s", err ? err->message : "(no detail)"); if (err) { g_error_free(err); err = NULL; } } printf("\n"); if (result) *result = TRUE; } else { if (result) *result = FALSE; } return TRUE; } i++; } return FALSE; } gboolean _scan(LDM *const ldm, gboolean ignore_errors, const gint argc, gchar ** const argv, JsonBuilder * const jb) { wordexp_t p = {0,}; for (int i = 0; i < argc; i++) { gchar * const pattern = argv[i]; if (wordexp(pattern, &p, WRDE_REUSE) != 0) { /* FIXME: diagnose this? */ } else { for (size_t j = 0; j < p.we_wordc; j++) { gchar * const path = p.we_wordv[j]; GError *err = NULL; if (!ldm_add(ldm, path, &err)) { if (!ignore_errors && (err->domain != LDM_ERROR || err->code != LDM_ERROR_NOT_LDM)) { g_warning("Error scanning %s: %s", path, err->message); } g_error_free(err); err = NULL; } } } } wordfree(&p); if (jb) { json_builder_begin_array(jb); GArray * const dgs = ldm_get_disk_groups(ldm); for (guint i = 0; i < dgs->len; i++) { LDMDiskGroup * const dg = g_array_index(dgs, LDMDiskGroup *, i); gchar *guid = ldm_disk_group_get_guid(dg); json_builder_add_string_value(jb, guid); g_free(guid); } g_array_unref(dgs); json_builder_end_array(jb); } return TRUE; } gboolean ldm_scan(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { return _scan(ldm, FALSE, argc, argv, jb); } void show_json_array(JsonBuilder * const jb, const GArray * const array, const gchar * const name) { json_builder_set_member_name(jb, name); json_builder_begin_array(jb); for (guint i = 0; i < array->len; i++) { GObject * const o = g_array_index(array, GObject *, i); gchar *value; g_object_get(o, "name", &value, NULL); json_builder_add_string_value(jb, value); g_free(value); } json_builder_end_array(jb); } LDMDiskGroup * find_diskgroup(LDM * const ldm, const gchar * const guid) { LDMDiskGroup *dg = NULL; GArray * const diskgroups = ldm_get_disk_groups(ldm); for (guint i = 0; i < diskgroups->len; i++) { LDMDiskGroup * const dg_i = g_array_index(diskgroups, LDMDiskGroup *, i); gchar *guid_i = ldm_disk_group_get_guid(dg_i); if (g_strcmp0(guid_i, guid) == 0) { dg = dg_i; g_free(guid_i); break; } g_free(guid_i); } if (dg) { g_object_ref(dg); } else { g_warning("No such disk group: %s", guid); } g_array_unref(diskgroups); return dg; } gboolean show_diskgroup(LDM * const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { if (argc != 1) return usage_show(); LDMDiskGroup *dg = find_diskgroup(ldm, argv[0]); if (!dg) return FALSE; gchar *name = ldm_disk_group_get_name(dg); json_builder_begin_object(jb); json_builder_set_member_name(jb, "name"); json_builder_add_string_value(jb, name); json_builder_set_member_name(jb, "guid"); json_builder_add_string_value(jb, argv[0]); g_free(name); GArray * const volumes = ldm_disk_group_get_volumes(dg); show_json_array(jb, volumes, "volumes"); g_array_unref(volumes); GArray * const disks = ldm_disk_group_get_disks(dg); show_json_array(jb, disks, "disks"); g_array_unref(disks); json_builder_end_object(jb); g_object_unref(dg); return TRUE; } gboolean show_volume(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { if (argc != 2) return usage_show(); LDMDiskGroup *dg = find_diskgroup(ldm, argv[0]); if (!dg) return FALSE; GArray * const volumes = ldm_disk_group_get_volumes(dg); g_object_unref(dg); gboolean found = FALSE; for (guint i = 0; i < volumes->len; i++) { LDMVolume * const vol = g_array_index(volumes, LDMVolume *, i); gchar *name = ldm_volume_get_name(vol); if (g_strcmp0(name, argv[1]) == 0) { found = TRUE; gchar *guid = ldm_volume_get_guid(vol); LDMVolumeType type = ldm_volume_get_voltype(vol); guint64 size = ldm_volume_get_size(vol); guint64 chunk_size = ldm_volume_get_chunk_size(vol); gchar *hint = ldm_volume_get_hint(vol); GError *err = NULL; gchar *device = ldm_volume_dm_get_device(vol, &err); if (err) { g_warning("Unable to get device for volume %s with GUID %s: %s", name, guid, err->message); g_error_free(err); } json_builder_begin_object(jb); GEnumValue * const type_v = g_enum_get_value(g_type_class_peek(LDM_TYPE_VOLUME_TYPE), type); json_builder_set_member_name(jb, "name"); json_builder_add_string_value(jb, name); json_builder_set_member_name(jb, "guid"); json_builder_add_string_value(jb, guid); json_builder_set_member_name(jb, "type"); json_builder_add_string_value(jb, type_v->value_nick); json_builder_set_member_name(jb, "size"); json_builder_add_int_value(jb, size); json_builder_set_member_name(jb, "chunk-size"); json_builder_add_int_value(jb, chunk_size); if (hint != NULL) { json_builder_set_member_name(jb, "hint"); json_builder_add_string_value(jb, hint); } if (device != NULL) { json_builder_set_member_name(jb, "device"); json_builder_add_string_value(jb, device); } json_builder_set_member_name(jb, "partitions"); json_builder_begin_array(jb); GArray * const partitions = ldm_volume_get_partitions(vol); for (guint j = 0; j < partitions->len; j++) { LDMPartition * const part = g_array_index(partitions, LDMPartition *, j); gchar *partname = ldm_partition_get_name(part); json_builder_add_string_value(jb, partname); g_free(partname); } g_array_unref(partitions); json_builder_end_array(jb); json_builder_end_object(jb); g_free(guid); g_free(hint); g_free(device); } g_free(name); if (found) break; } g_array_unref(volumes); return found; } gboolean show_partition(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { if (argc != 2) return usage_show(); LDMDiskGroup *dg = find_diskgroup(ldm, argv[0]); if (!dg) return FALSE; GArray * const parts = ldm_disk_group_get_partitions(dg); g_object_unref(dg); gboolean found = FALSE; for (guint i = 0; i < parts->len; i++) { LDMPartition * const part = g_array_index(parts, LDMPartition *, i); gchar *name = ldm_partition_get_name(part); if (g_strcmp0(name, argv[1]) == 0) { found = TRUE; guint64 start = ldm_partition_get_start(part); guint64 size = ldm_partition_get_size(part); LDMDisk * const disk = ldm_partition_get_disk(part); gchar *diskname = ldm_disk_get_name(disk); g_object_unref(disk); GError *err = NULL; gchar *device = ldm_partition_dm_get_device(part, &err); if (err) { g_warning("Unable to get device for partition %s on disk %s: %s", name, diskname, err->message); g_error_free(err); } json_builder_begin_object(jb); json_builder_set_member_name(jb, "name"); json_builder_add_string_value(jb, name); json_builder_set_member_name(jb, "start"); json_builder_add_int_value(jb, start); json_builder_set_member_name(jb, "size"); json_builder_add_int_value(jb, size); json_builder_set_member_name(jb, "disk"); json_builder_add_string_value(jb, diskname); if (device != NULL) { json_builder_set_member_name(jb, "device"); json_builder_add_string_value(jb, device); } json_builder_end_object(jb); g_free(diskname); g_free(device); } g_free(name); if (found) break; } g_array_unref(parts); return found; } gboolean show_disk(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { if (argc != 2) return usage_show(); LDMDiskGroup *dg = find_diskgroup(ldm, argv[0]); if (!dg) return FALSE; GArray * const disks = ldm_disk_group_get_disks(dg); g_object_unref(dg); gboolean found = FALSE; for (guint i = 0; i < disks->len; i++) { LDMDisk * const disk = g_array_index(disks, LDMDisk *, i); gchar *name = ldm_disk_get_name(disk); if (g_strcmp0(name, argv[1]) == 0) { found = TRUE; gchar *guid = ldm_disk_get_guid(disk); gchar *device = ldm_disk_get_device(disk); guint64 data_start = ldm_disk_get_data_start(disk); guint64 data_size = ldm_disk_get_data_size(disk); guint64 metadata_start = ldm_disk_get_metadata_start(disk); guint64 metadata_size = ldm_disk_get_metadata_size(disk); json_builder_begin_object(jb); json_builder_set_member_name(jb, "name"); json_builder_add_string_value(jb, name); json_builder_set_member_name(jb, "guid"); json_builder_add_string_value(jb, guid); json_builder_set_member_name(jb, "present"); json_builder_add_boolean_value(jb, device ? TRUE : FALSE); if (device) { json_builder_set_member_name(jb, "device"); json_builder_add_string_value(jb, device); json_builder_set_member_name(jb, "data-start"); json_builder_add_int_value(jb, data_start); json_builder_set_member_name(jb, "data-size"); json_builder_add_int_value(jb, data_size); json_builder_set_member_name(jb, "metadata-start"); json_builder_add_int_value(jb, metadata_start); json_builder_set_member_name(jb, "metadata-size"); json_builder_add_int_value(jb, metadata_size); } json_builder_end_object(jb); g_free(guid); g_free(device); } g_free(name); if (found) break; } g_array_unref(disks); return found; } gboolean ldm_show(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { if (argc == 0) return usage_show(); if (g_strcmp0(argv[0], "diskgroup") == 0) { return show_diskgroup(ldm, argc - 1, argv + 1, jb); } else if (g_strcmp0(argv[0], "volume") == 0) { return show_volume(ldm, argc - 1, argv + 1, jb); } else if (g_strcmp0(argv[0], "partition") == 0) { return show_partition(ldm, argc - 1, argv + 1, jb); } else if (g_strcmp0(argv[0], "disk") == 0) { return show_disk(ldm, argc - 1, argv + 1, jb); } return usage_show(); } typedef gboolean (*_usage_t)(); typedef gboolean (*_vol_action_t)(const LDMVolume *, GString **, GError **); static gboolean _ldm_vol_action(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb, const gchar * const action_desc, _usage_t const usage, _vol_action_t const action) { json_builder_begin_array(jb); if (argc == 1) { if (g_strcmp0(argv[0], "all") != 0) return (*usage)(); GArray *dgs = ldm_get_disk_groups(ldm); for (guint i = 0; i < dgs->len; i++) { LDMDiskGroup * const dg = g_array_index(dgs, LDMDiskGroup *, i); GArray *volumes = ldm_disk_group_get_volumes(dg); for (guint j = 0; j < volumes->len; j++) { LDMVolume * const vol = g_array_index(volumes, LDMVolume *, j); GError *err = NULL; GString *device = NULL; if (!(*action)(vol, &device, &err)) { gchar *vol_name = ldm_volume_get_name(vol); gchar *dg_guid = ldm_disk_group_get_guid(dg); g_warning("Unable to %s volume %s in disk group %s: %s", action_desc, vol_name, dg_guid, err->message); g_free(vol_name); g_free(dg_guid); g_error_free(err); err = NULL; } if (device) { json_builder_add_string_value(jb, device->str); g_string_free(device, TRUE); } } } g_array_unref(dgs); } else if (argc == 3) { if (g_strcmp0(argv[0], "volume") != 0) return (*usage)(); LDMDiskGroup * const dg = find_diskgroup(ldm, argv[1]); if (!dg) return FALSE; GArray * const volumes = ldm_disk_group_get_volumes(dg); LDMVolume *vol = NULL; for (guint i = 0; i < volumes->len; i++) { LDMVolume * const o = g_array_index(volumes, LDMVolume *, i); gchar *name = ldm_volume_get_name(o); if (g_strcmp0(name, argv[2]) == 0) vol = o; g_free(name); if (vol) break; } g_object_unref(dg); g_array_unref(volumes); if (!vol) { g_warning("Disk group %s doesn't contain volume %s", argv[1], argv[2]); return FALSE; } GError *err = NULL; GString *device = NULL; if (!(*action)(vol, &device, &err)) { g_warning("Unable to %s volume %s in disk group %s: %s", action_desc, argv[2], argv[1], err->message); g_error_free(err); err = NULL; return FALSE; } if (device) { json_builder_add_string_value(jb, device->str); g_string_free(device, TRUE); } } else { return (*usage)(); } json_builder_end_array(jb); return TRUE; } gboolean ldm_create(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { return _ldm_vol_action(ldm, argc, argv, jb, "create", usage_create, ldm_volume_dm_create); } gboolean ldm_remove(LDM *const ldm, const gint argc, gchar ** const argv, JsonBuilder * const jb) { return _ldm_vol_action(ldm, argc, argv, jb, "remove", usage_remove, ldm_volume_dm_remove); } gboolean shell(LDM * const ldm, gchar ** const devices, JsonGenerator * const jg, GOutputStream * const out) { int history_len = 0; rl_readline_name = "ldmtool"; char histfile[1024] = ""; const char * const home = getenv("HOME"); if (home) { snprintf(histfile, sizeof(histfile), "%s/.ldmtool", home); using_history(); int r = read_history(histfile); if (r != 0 && r != ENOENT) { g_warning("Unable to read history from %s: %s", histfile, strerror(r)); } } JsonBuilder *jb = json_builder_new(); for (;;) { char * line = readline("ldm> "); if (!line) { printf("\n"); break; } GError *err = NULL; gint argc = 0; gchar **argv = NULL; if (!g_shell_parse_argv(line, &argc, &argv, &err)) { if (err->domain != G_SHELL_ERROR || err->code != G_SHELL_ERROR_EMPTY_STRING) { g_warning("Error parsing command: %s", err->message); } g_error_free(err); err = NULL; } if (argc == 0) { free(line); continue; } add_history(line); history_len++; free(line); gboolean result = FALSE; if (!do_command(ldm, argc, argv, &result, out, jg, jb)) { if (g_strcmp0("quit", argv[0]) == 0 || g_strcmp0("exit", argv[0]) == 0) { g_strfreev(argv); break; } if (g_strcmp0("help", argv[0]) == 0) { printf("Usage:\n%s\n", USAGE_ALL); } else { printf("Unrecognised command: %s\n", argv[0]); } } if (result) json_builder_reset(jb); g_strfreev(argv); } g_object_unref(jb); if (histfile[0] != '\0') { /* append_history requires the file to exist already */ int fd = open(histfile, O_WRONLY|O_CREAT|O_NOCTTY|O_CLOEXEC, 0600); if (fd == -1) { g_warning("Unable to create history file %s: %m", histfile); } else { close(fd); int r = append_history(history_len, histfile); if (r != 0) { g_warning("Unable to save history to %s: %s", histfile, strerror(r)); } } } return TRUE; } void _array_free(gpointer data) { char **str_p = data; g_free(*str_p); } GArray * get_devices(void) { DIR *dir = opendir("/sys/block"); if (dir == NULL) { g_warning("Unable to open /sys/block: %m"); return NULL; } GArray *ret = g_array_new(TRUE, FALSE, sizeof(char *)); g_array_set_clear_func(ret, _array_free); struct dirent *entry; for (;;) { entry = readdir(dir); if (entry == NULL) break; if (g_strcmp0(entry->d_name, ".") == 0 || g_strcmp0(entry->d_name, "..") == 0) continue; char *device; if (asprintf(&device, "/dev/%s", entry->d_name) == -1) { g_error("malloc failure in asprintf"); } g_array_append_val(ret, device); } closedir(dir); return ret; } gboolean cmdline(LDM * const ldm, gchar **devices, JsonGenerator * const jg, GOutputStream * const out, const int argc, char *argv[]) { GArray * scanned = NULL; if (!devices) { scanned = get_devices(); devices = (gchar **) scanned->data; } JsonBuilder *jb = NULL; if (!_scan(ldm, TRUE, g_strv_length(devices), devices, NULL)) goto error; jb = json_builder_new(); gboolean result; if (!do_command(ldm, argc, argv, &result, out, jg, jb)) { g_warning("Unrecognised command: %s", argv[0]); goto error; } if (scanned) g_array_unref(scanned); g_object_unref(jb); return result; error: if (scanned) g_array_unref(scanned); if (jb) g_object_unref(jb); return FALSE; } void ldmtool_log(const gchar * const log_domain, const GLogLevelFlags log_level, const gchar * const message, gpointer const user_data) { if (log_level & G_LOG_LEVEL_DEBUG) { /* Ignore debug messages */ } else if (log_level & (G_LOG_LEVEL_INFO | G_LOG_LEVEL_MESSAGE)) { printf("%s\n", message); } else { fprintf(stderr, "%s\n", message); } } int main(int argc, char *argv[]) { static gchar **devices = NULL; static const GOptionEntry entries[] = { { "device", 'd', 0, G_OPTION_ARG_FILENAME_ARRAY, &devices, "Block device to scan for LDM metadata", NULL }, { NULL } }; GError *err = NULL; g_log_set_handler(NULL, G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO, ldmtool_log, NULL); GOptionContext *context = g_option_context_new("[command ]"); g_option_context_set_summary(context, "Available commands:\n" USAGE_ALL); g_option_context_add_main_entries(context, entries, NULL); if(!g_option_context_parse(context, &argc, &argv, &err)) { g_warning("option parsing failed: %s", err->message); return 1; } g_option_context_free(context); #if !GLIB_CHECK_VERSION(2,35,0) g_type_init(); #endif LDM * const ldm = ldm_new(&err); int ret = 0; GOutputStream *out = g_unix_output_stream_new(STDOUT_FILENO, FALSE); JsonGenerator *jg = json_generator_new(); json_generator_set_pretty(jg, TRUE); json_generator_set_indent(jg, 2); if (argc > 1) { if (!cmdline(ldm, devices, jg, out, argc - 1, argv + 1)) { ret = 1; } } else { if (!shell(ldm, devices, jg, out)) { ret = 1; } } g_object_unref(jg); g_strfreev(devices); g_object_unref(ldm); if (!g_output_stream_close(out, NULL, &err)) { g_warning("Error closing output stream: %s", err->message); } g_object_unref(out); return ret; } libldm-libldm-0.2.5/src/mbr.c000066400000000000000000000044751402606704000157460ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #include #include #include #include "mbr.h" struct _part { uint8_t status; uint8_t first_head; uint8_t first_cs[2]; uint8_t type; uint8_t last_head; uint8_t last_cs[2]; uint32_t first_lba; uint32_t n_sectors; } __attribute__((__packed__)); struct _mbr { char code[446]; struct _part part[4]; uint8_t magic[2]; } __attribute__((__packed__)); int mbr_read(int fd, mbr_t *mbr) { struct _mbr _mbr; size_t rb = 0; while (rb < sizeof(_mbr)) { ssize_t in = pread(fd, &_mbr + rb, sizeof(struct _mbr) - rb, rb); if (in == 0) return -MBR_ERROR_INVALID; if (in == -1) return -MBR_ERROR_READ; rb += in; } if (_mbr.magic[0] != 0x55 || _mbr.magic[1] != 0xAA) return -MBR_ERROR_INVALID; for (int i = 0; i < 4; i++) { struct _part *_part = &_mbr.part[i]; mbr_part_t *part = &mbr->part[i]; part->status = _part->status; part->first_head = _part->first_head; part->first_sector = _part->first_cs[0] & 0x3F; part->first_cylinder = (uint16_t) (_part->first_cs[0] & 0xC0) + (uint16_t) (_part->first_cs[1]); part->type = _part->type; part->last_head = _part->last_head; part->last_sector = _part->last_cs[0] & 0x3F; part->last_cylinder = (uint16_t) (_part->last_cs[0] & 0xC0) + (uint16_t) (_part->last_cs[1]); part->first_lba = le32toh(_part->first_lba); part->n_sectors = le32toh(_part->n_sectors); } return 0; } libldm-libldm-0.2.5/src/mbr.h000066400000000000000000000042671402606704000157520ustar00rootroot00000000000000/* libldm * Copyright 2012 Red Hat 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 . */ #include typedef enum { MBR_ERROR_OK, MBR_ERROR_READ, MBR_ERROR_INVALID } mbr_error_t; typedef enum { MBR_PART_EMPTY = 0x00, MBR_PART_FAT16 = 0x04, MBR_PART_EXTENDED = 0x05, MBR_PART_FAT16B = 0x06, MBR_PART_NTFS = 0x07, MBR_PART_FAT32 = 0x0B, MBR_PART_FAT32_LBA = 0x0C, MBR_PART_FAT16_LBA = 0x0E, MBR_PART_EXTENDED_LBA = 0x0F, MBR_PART_NTFS_HIDDEN = 0x27, MBR_PART_WINDOWS_LDM = 0x42, MBR_PART_LINUX = 0x83, MBR_PART_EXTENDED_LINUX = 0x85, MBR_PART_LINUX_LVM = 0x8E, MBR_PART_EFI_PROTECTIVE = 0xEE } mbr_part_type_t; typedef struct _mbr_ext_t mbr_ext_t; typedef struct { uint8_t status; uint8_t first_head; uint16_t first_cylinder; /* Only 10 bits are usable */ uint8_t first_sector; mbr_part_type_t type; uint8_t last_head; uint16_t last_cylinder; /* Only 10 bits are usable */ uint8_t last_sector; uint32_t first_lba; uint32_t n_sectors; mbr_ext_t *ext; } mbr_part_t; typedef struct { char code[440]; uint32_t signature; mbr_part_t part[4]; } mbr_t; struct _mbr_ext_t { char code[446]; mbr_part_t part[4]; mbr_part_t *_parent; uint32_t _start; }; int mbr_read(int fd, mbr_t *mbr); //int mbr_read_extended(int fd, mbr_part *part, mbr_ext *ext); libldm-libldm-0.2.5/test/000077500000000000000000000000001402606704000152005ustar00rootroot00000000000000libldm-libldm-0.2.5/test/.gitignore000066400000000000000000000006301402606704000171670ustar00rootroot000000000000002003R2_MIRRORED* 2003R2_MIRRORED_partial_1* 2003R2_MIRRORED_partial_2* 2003R2_RAID5* 2003R2_RAID5_partial_1* 2003R2_RAID5_partial_2* 2003R2_RAID5_partial_3* 2003R2_SIMPLE* 2003R2_SPANNED* 2003R2_STRIPED* 2008R2_MIRRORED* 2008R2_MIRRORED_partial_1* 2008R2_MIRRORED_partial_2* 2008R2_RAID5* 2008R2_RAID5_partial_1* 2008R2_RAID5_partial_2* 2008R2_RAID5_partial_3* 2008R2_SPANNED* 2008R2_STRIPED* test-suite.log libldm-libldm-0.2.5/test/Makefile.am000066400000000000000000000114741402606704000172430ustar00rootroot00000000000000# libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . AM_CFLAGS = -Wall -Werror EXTRA_DIST = checkmount.pl data/ldm-data.tar.xz check_PROGRAMS = partread ldmread partread_CFLAGS = $(AM_CFLAGS) -I$(top_srcdir)/src partread_LDADD = $(top_builddir)/src/libldm-1.0.la ldmread_CFLAGS = $(AM_CFLAGS) -I$(top_srcdir)/src $(GOBJECT_CFLAGS) ldmread_LDADD = $(top_builddir)/src/libldm-1.0.la $(GOBJECT_LIBS) 2003R2_DG = 03c0c4fc-8b6f-402b-9431-4be2e5823b1c 2008R2_DG = 06495a84-fbfd-11e1-8cf9-52540061f5db 2003R2_SIMPLE = \ data/ldm-2003r2-simple-1.img 2003R2_SIMPLE_volume = $(2003R2_DG) Volume1 2003R2_SPANNED = \ data/ldm-2003r2-spanned-1.img \ data/ldm-2003r2-spanned-2.img 2003R2_SPANNED_volume = $(2003R2_DG) Volume2 2003R2_STRIPED = \ data/ldm-2003r2-striped-1.img \ data/ldm-2003r2-striped-2.img 2003R2_STRIPED_volume = $(2003R2_DG) Stripe1 2003R2_MIRRORED = \ data/ldm-2003r2-mirrored-1.img \ data/ldm-2003r2-mirrored-2.img 2003R2_MIRRORED_partial_1 = \ data/ldm-2003r2-mirrored-1.img 2003R2_MIRRORED_partial_2 = \ data/ldm-2003r2-mirrored-2.img 2003R2_MIRRORED_volume = $(2003R2_DG) Volume3 2003R2_MIRRORED_partial_1_volume = $(2003R2_DG) Volume3 2003R2_MIRRORED_partial_2_volume = $(2003R2_DG) Volume3 2003R2_RAID5 = \ data/ldm-2003r2-raid5-1.img \ data/ldm-2003r2-raid5-2.img \ data/ldm-2003r2-raid5-3.img 2003R2_RAID5_partial_1 = \ data/ldm-2003r2-raid5-1.img \ data/ldm-2003r2-raid5-2.img 2003R2_RAID5_partial_2 = \ data/ldm-2003r2-raid5-2.img \ data/ldm-2003r2-raid5-3.img 2003R2_RAID5_partial_3 = \ data/ldm-2003r2-raid5-1.img \ data/ldm-2003r2-raid5-3.img 2003R2_RAID5_volume = $(2003R2_DG) Raid1 2003R2_RAID5_partial_1_volume = $(2003R2_DG) Raid1 2003R2_RAID5_partial_2_volume = $(2003R2_DG) Raid1 2003R2_RAID5_partial_3_volume = $(2003R2_DG) Raid1 2008R2_SPANNED = \ data/ldm-2008r2-spanned-1.img \ data/ldm-2008r2-spanned-2.img 2008R2_SPANNED_volume = $(2008R2_DG) Volume1 2008R2_STRIPED = \ data/ldm-2008r2-striped-1.img \ data/ldm-2008r2-striped-2.img 2008R2_STRIPED_volume = $(2008R2_DG) Volume2 2008R2_MIRRORED = \ data/ldm-2008r2-mirrored-1.img \ data/ldm-2008r2-mirrored-2.img 2008R2_MIRRORED_partial_1 = \ data/ldm-2008r2-mirrored-1.img 2008R2_MIRRORED_partial_2 = \ data/ldm-2008r2-mirrored-2.img 2008R2_MIRRORED_volume = $(2008R2_DG) Volume3 2008R2_MIRRORED_partial_1_volume = $(2008R2_DG) Volume3 2008R2_MIRRORED_partial_2_volume = $(2008R2_DG) Volume3 2008R2_RAID5 = \ data/ldm-2008r2-raid5-1.img \ data/ldm-2008r2-raid5-2.img \ data/ldm-2008r2-raid5-3.img 2008R2_RAID5_partial_1 = \ data/ldm-2008r2-raid5-1.img \ data/ldm-2008r2-raid5-2.img 2008R2_RAID5_partial_2 = \ data/ldm-2008r2-raid5-2.img \ data/ldm-2008r2-raid5-3.img 2008R2_RAID5_partial_3 = \ data/ldm-2008r2-raid5-1.img \ data/ldm-2008r2-raid5-3.img 2008R2_RAID5_volume = $(2008R2_DG) Volume4 2008R2_RAID5_partial_1_volume = $(2008R2_DG) Volume4 2008R2_RAID5_partial_2_volume = $(2008R2_DG) Volume4 2008R2_RAID5_partial_3_volume = $(2008R2_DG) Volume4 img_files = \ $(2003R2_SIMPLE) \ $(2003R2_SPANNED) \ $(2003R2_STRIPED) \ $(2003R2_MIRRORED) \ $(2003R2_RAID5) \ $(2008R2_SPANNED) \ $(2008R2_STRIPED) \ $(2008R2_MIRRORED) \ $(2008R2_RAID5) $(img_files): data/ldm-data.tar.xz Makefile mkdir -p $(builddir)/data tar -C $(builddir)/data -SJxf $< && touch $(img_files) data: $(img_files) # The RAID5 partial tests aren't passing. Kernel error message is: # md/raid:mdX: cannot start dirty degraded array. TESTS = \ 2003R2_SIMPLE \ 2003R2_SPANNED \ 2003R2_STRIPED \ 2003R2_MIRRORED \ 2003R2_RAID5 \ 2008R2_SPANNED \ 2008R2_STRIPED \ 2008R2_MIRRORED \ 2008R2_RAID5 \ 2003R2_MIRRORED_partial_1 \ 2003R2_MIRRORED_partial_2 \ 2008R2_MIRRORED_partial_1 \ 2008R2_MIRRORED_partial_2 \ #2003R2_RAID5_partial_1 \ #2003R2_RAID5_partial_2 \ #2003R2_RAID5_partial_3 \ #2008R2_RAID5_partial_1 \ #2008R2_RAID5_partial_2 \ #2008R2_RAID5_partial_3 $(TESTS): Makefile.am checkmount.pl $(img_files) echo "#!/bin/sh" > $@ echo "sudo $(srcdir)/checkmount.pl $(top_builddir)/src $($@_volume) $($@)" >> $@ chmod 755 $@ .PHONY: data CLEANFILES = $(TESTS) $(img_files) libldm-libldm-0.2.5/test/checkmount.pl000077500000000000000000000041151402606704000177010ustar00rootroot00000000000000#!/usr/bin/perl # libldm # Copyright 2012 Red Hat Inc. # # 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 # (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, see . use strict; use warnings; use File::Temp qw(tempdir); use JSON::PP; my @loops; my @dm_devices; my $mount = tempdir(CLEANUP => 1); my $mounted = 0; my $builddir = shift @ARGV; my $dg = shift @ARGV; my $vol = shift @ARGV; sub umount { my $dir = shift; my $tries = 0; do { return if (system('umount', $mount) == 0); sleep(1); $tries++; } while ($tries < 3) } END { my $err = $?; umount($mount) if (defined($mount) && $mounted); while(@dm_devices) { system('dmsetup', 'remove', pop(@dm_devices)); } while(@loops) { system('losetup', '-d', pop(@loops)); } $? = $err; } my @loop_args; foreach my $arg (@ARGV) { my $loop = `losetup -f --show $arg`; chomp($loop); push(@loops, $loop); push(@loop_args, '-d', $loop); } my $json = JSON::PP->new(); open(JSON, '-|', "$builddir/ldmtool", @loop_args, 'create', 'volume', $dg, $vol) or die("Unable to run ldmtool"); while() { $json->incr_parse($_); } close(JSON); my $tested = 0; foreach my $device (@{$json->incr_parse}) { system('mount', "/dev/mapper/$device", $mount); $mounted = 1; open(TEST, '<', "$mount/test.txt") or die "Test file missing"; my $line = ; close(TEST); umount($mount); $mounted = 0; `$builddir/ldmtool remove all`; exit(1) unless $line eq 'Filesystem test'; $tested = 1; } exit($tested ? 0 : 1); libldm-libldm-0.2.5/test/data/000077500000000000000000000000001402606704000161115ustar00rootroot00000000000000libldm-libldm-0.2.5/test/data/.gitignore000066400000000000000000000000071402606704000200760ustar00rootroot00000000000000/*.img libldm-libldm-0.2.5/test/data/ldm-data.tar.xz000066400000000000000000005767201402606704000207650ustar00rootroot000000000000007zXZִF!t/!f]6 +%L(ӆ?eztR=TWd2d?v{E'JGt" 5E$(g 9@p =lC݁hOڤ鵡C4{lJP9DR+CGVItjú5vo[7o{8wsU¦ D<[.&1 q{Vד!D\:$^fr4w1"f xT)ȍ RYd6;ޅrav-*4Ls.1s3_i;5^c΄:Qo7[AHwiGnbhB7}.#x[9fJxuDB5{3mm|uSJvO]Tc +Lfҏs4GleDf  Ge[%W"z _AXUQJnSlR󱿄z3Pj7$#\hMKˆ6Z _l!*W6m)_"4p!xGwyR>~A"ź}>] &uvFOGaYLG>ՍN=sa  K8kg˜u؜sk#G6\R({B$`Ҏ֭ r IwZ:81j%[AΩcz!$. b>{@T"eR6s֏9P F2\ћ2CQy"Y/ t~I^2z%1z^# ϕ.{E#Di(tVS)yg@ ;h'2>)n |6U&tN fi|5 *f'BeystD|^< ]At3 '.69&uѓ͙򌏘{@,N:ác8P| K>l¯3]?IʔËR\Vp{ug&/J(u#Jpcs זlp:Yb>: yQef6ֳˇ*ֻ_y 6+8I+42՝aH=)W{uLYq請z÷_J63S!Cif$PMQ5$߫TF~~Sk摸ԃk9 k(Ҙ\'qtWoAH҃/iuI#+֩ͳ,v4/ˤ8,&ex׀%(|s1b'#Z63,ZqfTz>%BkC &yX4 ƾ',yȽQȽ~8$υGkUh9yCUTݞ_ͭh W=J2({>QS..: .,$d|mx: 6P[_vja)9upvP J T2ʼV2 ('+vC3GUS "(;D xBcL-`BL)_U%m0G`.vԊ#~ #fFĆ2Ƃ宷ͷ&x|"`OdnhUG~]=1) D˽q֘NOІ`/p)jp.0{,x c@PrNmv6`'Wzp=o(^RC~ EJc]0d@:Ai8 3wfӎhO=#jF–\v޷ ͽS=Ox@p=Hq4jtX&vȒʱ̱Lswcp)Ő gtS. 9I\־s | 5L*t^<0 {dGPs$\h ~H43q ojtE^Y;qh炍P_BefPyᣅ%|ٹ_( otZk4r,$OK~YVXV]#+:qO_މ ']v:闇u3>DwZ~)˭Wtw9θlU2)Lb`Վiَ6zY\QqJwR~n+Tl5r#H:E!ϱw'~C.995%޵kO=ّɷ!@nU. ]6R?m\ee):=``'vz;1+QDs%m̱4`2Ɂ,3[a-@_xQm#R(<(OI"o?$O!at>KF#.njD'7);p`o>k`Y|J PI\I9O(һ lHƐxf`h,^Գɚ8hpLNK7v ^J:&d7ϡc:n'%TG]D|X!%܎{w#cXXetzo6qBL֚ qY~ jc~>d={P$ȜkfԄ*=W]i.E8Rƭ:9 Wu|BSZ`QH) _Sefz뽮ΐ rCSa50: \/ES^s Jxg7p˽O)Z٠PO7#Yykn ቲ(H?כn҃E5D߁Y>\]>CT9S0̃cÞ)sҒjQ0c?ļ%I4Ǣ,a&k ye'G~Lڔe>9I5xGŅ%Zӽ ^1[0oR5?5E?+!15,ꔅ4/3L5z+n٦d[cg4iZ<:yFl:j  (3iF\ʰF4haQYԋAʠKkZI't/:3:| (.~Dh?QB$!_0ڊS0Itsʫ,S,E|\tHk Kވ"}<ҭ෈-㜔%\.Oh\~Y;|0jRtoH¼nh:4~VG FpKbOPn';$)&PYk%=vz.H'8:jB.~-9i;6 hΪ.P>9x^E"#@3_GVO:\scKz?yr2f G|E4>'v3-F~*kEso8 5"=!d/& di x+}H@揫"A=WzQF4m9`d|GV&6n̠lQNf7A~:؅th<ӵH=er\1Z J5k:.Dg]{܄YֵJ$:^u'a]c6cQGD˽WL]U_t=ͧHѶl #Ȫ߅g9/D.ǔ9H09'W#\o? w R tLlxMQYi|lTzsWހ±Z?WxbnTZBt?wXk7T)Z eI8^hO vۄq3 PR3W ͋B.\9] x) !a/',,CdM]s.C_% 3 }IR~#g]Wn g*z|3 "x% e)|2u}I1=E+U-گf{uDcgo-)F[u%0ۊҴm҈Rj8--.fq,<{}R}dvF\+4EtId{RV+̏*Q_\vUjYP $–=ްG*HL>A#9A6*]Gzl>bQm{KbL>iW϶_-aԜ'MW\|8JL1X]l,Ԭ+XH̓[F%/n߼#SR_?*J+/Bۯw,)ij˺2++j <bI*ã}~9y90HWMt=*Ei;ZK?^ч`]{l׿5RkQmmYXnhV T!eRCVB>3j'Bg=pQrplI&fɃRxLߺcnۖǻOcH\wꥆzJв/:&yծۑQ/s^@4]6ཱ 9!0PFB{7wQRRhX8ywe4j4,G_,%^^V}Gff{D9 kPE06\sI:ˋW{Hҧ*vlGVkPR#A5wij1ޠ&4͚zU-/"RݴhUbyYs+hF׮OTd-S]2ic 2yomSM1rҲ0;g{iw+6A%m#2o4ŞFV{RYM6n;SΗ4s6ߊ_+) =^ aU!ʆp]-*yhvr qOkr6֞}4+ ͏3ipuOJX-?QD@n;g-G@'GPrS!GjaNflq(^z@tP`-ĈQW&0] {yP`3_#/Ƨ'/*˫U3B޳taQC8v3o)k~v7H*$$4aPx6,nRqIFck@'-G6c )t~`3).'z{Dܼ<7\ƚCNZ]mL^kC}:Jh\|L:2rAvo^3JSM fsbic*)(bGX <1Ș#^P{TW#slKqtdxַMgָ4(@1e[~O<S]EעE0Ac-BȰjrokY{)"5YmZn~0M&SC(c6kLw""|+ڬ#2WȌz-T PZBz-e j|7Ao,+Ƣ&5hӕElcioיt7xb 2kҼLm1/?ck&o%f},ecMJ[+.; AoG YFˉGv>jt }OJӍ7Fh0ani@+Z.54z!'9f~DzM>SbvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXvY[159NsygJ~mԕ2!/y*S>Ƴyri40 @D!YXka:N]xK݄^ΝUn4kpWߝ9[{9FBTov?yl+ZIN9c傒Z QFP(rzTeY Iߏ-%1<4FZA7>rR-.W<.'l=9HH:ЎlG'~'wO<̣ 7nG5~[d?3fƨvZZr N?wNgKQMKeLP;>5R,8\F.(z8"<<\M  ybSWvq4Xrs| 2!,?፪~_ÏVeb_mWHR_d&,A}(03Tzn'| Htb[#B@>hp32^XOE &!;6>n4gt.jp.e_a,v=;!0ܸ?l?m.ΐ6 Ut1lJ&ɔ:Sgi+Yb΋0*I8Wht`1~oPy&c8;$rpX9o(s$K)I.H 4dm9iD\hd>i9 u;KJwoi.c֮N愷6rţhKb$֓xL+#D,ڈcjJ7$@1!M.GdPb0PȀ"ݴUI{i2=.Hnzo!V˻2 !Rtg-:#6E)ha =vm^o 4Ū)L [P'G q4Jލ Rk!l ވ.vںKDZLwa;g(ju)߳ÃSl1hQgZO$uןzU=7N-jAL9s0R}+mXxC n>}[(OʌWif$9di$ҳ 6ǧiP\6GV7 JzO9fnZ΀PM,Q ˛ӵHCW]7OӋL TuV%P6.a~C`E\hz=\ђÇ9̔h̾R/;.Lrߪz,A]u=TþkkYq 3a5ǁ]wm1g6͆Ew^ )NdH 9?w@<=Qѽ 6Ơ9Xٟ%{ugA]e9% kIr22#/I0g4MFv"֬]&Y{6i3r.ܽPT`~tYB6zOgR{<]fn<07^lZ^'_D~: M;CyG[O`bzQa<VNV¯G|B>cVS~PmŢ{W?&@O*a6aTZ_#6SiB"%?a T_y/x?gy9y!pipE}YhpOPZ:XRJÒ/]pvjOݑniUx?`wg+pP_c)M5Ŏ2/昿'N;]{躟rmx>JxMބ-ht~ze=络;+{1n߱aBIsP?Bz7OcÔcfPd0.ǤnjoȈmȹVǵY /(rly_s}-!7,#jjK}"TmAcuzqY+cQ*TW>w9z'qF>xpE7 ( e"} {(V8qQ 0Xvi/wWHr"TюP0#SWP̦3C>XXGG֗/F c }FkzIgC=jDۊb6mA$+t;qlfEa۠UsM{Њk=z>z&[S)1ŀ?Sh P%9ßn`p_ ==Sz1,K.cu (e%wLsV -$h ,$r"WB(vY[Zҙ`,@G|;`&e"\I?yf^d=?l8WAZG'5HVan!ɭΠQsDP#H "bwr JT2sY}0P Z߅(w]xmD릜 1ٺ C:G})\ $w[Ym+40DT h'G#_8}!&tkjh񮨓vZtutbE:hy=(ɺ|iB鿖<|0~_qsza*D(Dۻ߰Ʋe{Iw ֢$,`Omk?7;赼r`/%ϐT㶴˽F)&j`Vda8/[WPHRjĠ|*T>D[̋M {g l$ƶM󽂰D6+4[R/$qV,.+Wӷbd0}5&|=h~J-fC`3nP{(?tl SY\:'MHV1t@Pp0<=$ \7 D)!e$W{L3C5@W] sTlud,TG%&PxA:G] H[.s"=P^]s|(hN:36@nߞt3TBL=!doB_(Oy|uO1 >)w 6LY2 Dq+wti8Q(KwRJ T!߹Mu|~Hvfw=OpC~1HK)gQu[:5u(xg U1bcH_Y^ӚvQ9zHD*!i"cO~&lrMD =\g6|SƄb?2ttyq E3G!& w ]& |ng+}ECQ% -ٔf ' !fGeH5xEFԅ;.>sU$1j8TLDs*`|@b{ϋAjzj*lSYڻ@R]L+E~"[fJ:]K.&IR3ddJu;Q:熶`j%`R"$fElg EBN hݨT4V-ԓndx6/<+{rLaDwՑ^j. Uk-EdN˜ː](LnC*+xک)~k=LƑW,:KM`=^!N닭blM3h%elXL֞b1[׀CTAےh0ƜyB3IqLV[)JjgoNImA& AW[,pfj*u-l OƴE(u$ .NAV-жk]Owq_{|Hu9pFSۼ/jl5Ire s|ݝume0`\SKWnbȷgNoLĒAUaT`[$݀6XGI&;L55c!ma2ƵQxpp0}_)#5Y{%ٱmorЋiߨ J vLjSUXP3Bi((ΔAG {iQIϽYU6IK[G~k&֢e)˅_yQ&`w>)A:S>hIy/M 2Ϣdrb ٭v}wa; egbU(1uU$)&. J{؄)9_sWhd+_}\* D>3 -[F ` sJmRj451A<ߡo½JtĐSlq+Q'8j{g(desPyXLsK cjjv02cOmU__u[|ggJ&%G^zCZ)%pAc*$Qq 5",5)2r.pTqGOԆ[{_أ-SķA9B7'| CFY&Kx#&u{|A")RՊ~ uX=T/M_/uF\7.eFXB=k6{GIO/A+YOH+U\+ Dhey˨&aorx5Wp! mr!QF|)D5)*9R@a%n'U%urj~e69Owc W²xN@x{:j/U\A*D:o].e6:U;uj4pϫt [XyP @pLC4fD jWbgtP1|7a"=\ހ+f3 `ϵ@>^7ڟ>c7R BT]]i^)W4m ,h=q'괂 Jd%[eq9ax%Gv?Imɚ\wlHhɵ ]{?48̔ ?_7},T~x}W%(Wĝ찵;;abnMiߏL˶O帗Y] :D+@zK"{b1"-;y%Ts&/8@ȃ tl®ή< {1kִ8óR:rdDJ kFDrx5=2 Y\AL'dPr.@fӓJ$'塒dǂ/*U5g)L=X=+ؐp+ݎI ]*#GD7p|+(WV' S4f\:\&vRbActo@0`Go?נ+6|>;knNS a 4I;!HrTi&C샔SȰ?վcW?w.#u/w%śzR&$Լ2*cw[#&O˶r-+ )w|-Oe:s@-gy /QȟEҖ.ҁ`h@f7{?t Q t,TVw^X!c520iq5Np.ݟMBJYJC"֘ԙ?0zVhZMMbzCu+jID>b5[H >WՅMgCWOK a/cE8m`cALe#fzqHs]C c='GAW^݈.=ݽ3-O7 ¿5@4P=S~ XoEK=c>;Ys{={#JoA|›&wc s/nmol915_3= dcvt#>t!IZOE~r7鼴 +\4^M5qɤKlߌ>G6Ϯ)LH㷇YRuy's y.@=C'U?'|܇ >H؞ a#}>8zfg[6M@]$C8<6ZĽ<:4WѨcINR#qPZq=IJS.{3G2q%' BLI(mKnΡM^R}ȃa!u"\[.}ϲFzWH◫B|Fk*2!NB\c}N4.G`|(QbqC5=UQ mDMkjQ?r}a!Hk3nDӦ<́g[X bbi*_:)0k"$ ڠsDh 8`P%K!/Cq_|[n'DKK8^Bi)5?ΐqnlWn-g|*kyFvuA$Ic#)(7QKJ/˷H('Sy"Ɵinvɧ WJ Hcaύ=fAa¶~x ʶt{6L͊XQNCf’I,}^aJrd??ahvocXqj.!Hksr&c!l/u0T1蕥w9&/M޼n0Oxyaob88GTWc^,5% +]Ț[0et8ju)iLOYŧ/|0WP +A3G% &o zA99=@ R,?X5ke }3}; Ȫ[xpFigae"}U)$9Wu{-փ?Yך6#&[Mb-`r(Ȱv ~+st ;詾i-~v$qf/}Zly$KermHV6t elԜx fy[7?tɡx. Oh4*\!dմ^]*p{zA=)km :(X`B=?$t5hx޷5O)n w㆒i"|Y;M!'e8^I Mw.YDy&#Q-3`ؾGf?FoŚt𴨚IbzQTKHՉIitW>-1&jX߂pTĂ Wbz&Ie< T:#-DDAbrz9H抔{LfÐu! ۈ01oqs{q8H8ثX.ĘmxĬYW*!x6QV{u['Um.):xd {@`XmS 7̿pCqǸ>8} x\i%&zK|$=[fY fb k"9 l9Frg,/k~}LDנOw:`s̑MOTY~^b|ގ1!i/z{^- # 5d:&Cfl>W[F\s/"cnQN (׾`j1c*H8`~k6Ѩ$Ŷ4k] @'ܙPޏK)v\d}\bB!K5q\& Ea+c7d%e~T>^&{8H]>Tb L=R'd.ɜGSaTޓ„O-zKԉOʹGq;Cd7 SI^T4D- o D%#gy+BtfjġIƿ$aUimezUD߇/>V#vh(!=i?oWK}3\gd' >ܖq̥HH@fm#[)['ɎXdB`? Ah rt=b:a%RʦVJKD. >^Cd.@ZSGM b4}K좂m`R T ##UӃTʻה,A4ڼ;L;e$uBiN)۵?Z~%TB[3 x;3,xZ#_%? AiwDCj`08l/b0Aջ;|a!Y}߲@BeF,Jp}JY?{ _KNnhAJ},TeBP·C7aR PjN 2c\d$*|N'˕-M%%gdFgqL(:d`ZIòQR (U1ݕ7$/I<w[2O*j@1maa<8 PLU]6QaP[UIA.V$#vYS7!K St-mL2eI!?Z4wn?AxՓ.#ҩ55Ke-ڀ&knbӲCK Ŝ~ O?YYaV9}`/6Q_Ynf?HcTb̨S{Vyb`b4f*#Zf{б;AyGK!D?ߪ_(uo ᆥ!t*wCמU[@ߵ#e8r|vs ݤcyiMcr4d] S,%ڈ,S&Wr3^@@;`CtB4֫낥50j0@b""=픓 (P(waJm)پ]՝I YLDn=A0kU}V8 Ն^AQ N'xKq/Kla! 1i}EJ>V>5O_*s|t0ؼgGux{^* K,M '⁀M\*iTKh1p[YqK)-õӗbqN K&b1~JzXcܦܞo\$2Z*^[}]m3ԇ &'K]ey~Ud'TH:/Obc;^bG3F3eY]u\Rk' in3O˯sJN>Fﵻjk<4?g*w2˵7ao ԰ӿ˘j^}!RH:Ye9%X3>'?Wc4s[sk,>A y$&UrQz/1PtʼwC5.Iq--JvV8Fv)pT"_@6%yPR$(&zs_ڻ L WYw!J!N~=ppJ$-sS3*a}Tc9lN>eG/2A;v~>JY KE̤-!1AMYrXR>ľJŐYw^T9dG((Q6 s!y؄Dx=&a -H 4[24tXMQ٤J\`%hyOtJ9XC]Ӗ_ByvNŒ ډnVʡa6㌇EhԌ,40[#faB 7١Z}mr9i#ÑbVirL (dLexJ\N y@ZceOW9z!T0KWXl~U8H|\lY n AU8y*% (9-ǗyCsbv\X)QX<Q$]*ߍ~D5 %rC $à]a*LpPp|<ɌWf qb>3ʮn\嶕ic3GX@BATd6A#?")kY-)J61zb^uz龣JlK8@?M?D04R")SN/P`};@" f6>iQH}ut߮8&'g f{&ۥ\< UԷb)\wyM?;q@%i@!4{pt&Hf*ܮiDkUc~ZS6À -Z1w -TL=,碄gzW-b/iV_8.h'5Z CHu:~#]_w4FE̒=W՜N5iru+ӿێUAPJV];6XbUGq[h/~4u6S{ 3Ў$C=W6]ޝ!Bq_xIHg` =K^3e>dS#NG:g}Yz-@qCL1d1g\2Ν Z%DXȥ Q:8d"05<<ݲO'ZA!")!xtW> =%zdWk$p-!Ϛ-IꕴU)>*.̖qWS'mSѰ` 3٫xm"?١K}>,!)(U uE]f 5h)c\;);k;:PX=@D+J+#WQ̟[ ݯ0tR*/$w*j4*=XydM|QS/JA`݂VEv2{ïpNWL٠"CC*D/ iA4 XKQPJݽ,dg!(ޛ;T[1: OgK~y:A44 FN8K6Oy=@)b;":ܦk(FT, r#[NGȳGrg.MԢ1I0ѹd~< xIdl}C6?N<^ yF<H+w1 +-[dljל݆6-j]ZeCfOG w-$nPT$Q>/!NR ` F 72VZ'yڣ6 qnPt'_žv'klN(!  %*x` 4\a 嫄t%"Q}m7" @^J73uBGLQk_Ȫ٣ 0$N܍=Q UZ/Tߔ$cr -!/,@xgF{G c ?e;Pa\kKAdv"RC8e|J/q^>y͇nB+Nh`W셀 ax;c__JVZM5bZ|Wb//v=ܪ;gN&z0 ! !ZPx,6vъW)<Ħ}vBk?~|{ e ll-hJzIjߕٞs >v/$$ հiAU/W Q`Tѷq ]"r3j%P׽u fS%"c|vK&BS~gЀﵭmFuܥh&q$#^*| hv\s9'B"'b a,WP])oKSBO7.(W{)}*.K!Rl#-Jg.2\IӄWb )8MpikXB=T$ՙr: &pjSȞ/R(}M%ae4zEgt/ ü4l1؂)}|n->wRu#[SFr\?>;C s|28 qQmI͊!ĕ^V"TwB _ c]HC+ξ;.0b_vʮHdɺ0BwNULsuȦ=ZB;.mh Uiմ-´N?jGCĆDt{&˼a#'2`s@1,aI3;++ a #ʘolr\GgAI^sg *W):AIu>j;+H;]|TiXEZ[:':@$/dwF9^RKځ/ ᘾpœлH#T;J| 21,)af\+0-7U7a7`3jVDm969(0OJz݂\|e!ÒiOzTSL2]"6T GFO 6^E>,A8^tCk:90Gßd 0e4N(rR 2irg'^VK[_H#EXod#a3;D\Y'e(8!"ZngE"O'mo+q1$mgf&W6(wXrXӄx.+-3J:J[ 'W2:Igl]*5(:du*֜Ecgj+tɵ|sD'p,}`Lm幀5@Oꗯ$(#JdTÿQYO@{˘gz,񎪢yK稩&2":_.!H z_nZVI@Ya2G|,"kI䮲qx%y8#1e&jcV|[F3j<ɖdꗕ\hk-MGniu>U3,]-a{-D\2uoMk 'R <*G`bdJǛhsY8\D Uy228Y:۾3q %x@VV0qXXfYITT~ n;D-5O-u5_uӴг&}i}R}FSfecO1j;=#W2pt1RᶞTq&ݴO4/r󵍔 L|W{` ]֤/$U\7TwLksN{pUu拕AuO4JEtrWnп4@ |Ádc Ms43lG_M0%UؙO Rv砮+~&aw;0X忁/~tm>;Ig)S1Ȩ0ЁO?=uv~Wess$6`uI$(Jvxk2T9xwɶ9}^$R#ұ['s|jqR(2ìI[>O^a6#wћzUhSZɩZ)Kr/LI["XHյ}JkBM`ItI *8i &54BokEYH_F+RXaRaRӃh(@= ;z(a2Q [֎\n ,^a{d\.sʺRCXIWGds9! 4yᣅJF罸Mǟ 5"uZ.ŤCQwۋw[㳫U ]TtSn1H*.x#^Q/MH7Pi/<mZav95da9VJ$B$Lب/ƊGƫ M}{E/aFSeu8F5DL3v@1Fmզvoa|bzg{5Tq1fR>v8!K@*5Z^09q+CbJIMyQַݏhCwuC"& L V.H{Ìu2טCwDrn1[,ߤ#!Aev`g+eY8A`1**fnI=\eo#s&,F yo-ծ gPUEɿ 'q[ lhr,:owޠ&Nт |MK7jv $ɆWrc>DaCAs'P=Cw y70;;t8Wsgز`(׹`Y1ʶ(A¾%˰bDK_W棧WvHRn;nqlegK~뾙Z;PT,U 9߄YWW3F)[MuD 1cb@y׶!3[_͹ݺ|JlPn*[[&$p#>woOof9HD*7\7RWv3ђ er}ԸX tIzבUV@Z Qi+be2DaZ2i5?,o-j 9X;Vt 3Xاs<MQ"/u3r"D~`ボ cmrƻ0;@A z)I1*}uI[dI tjQΊ=ROA:垉UV@ ^Vc2y֞㖟'7נ3R \RKT)217reЖ-8'E@E( ʬ8LDM%Ґ$U%7"OWxLI Eކv%b n!hot&ÒGBޫeOAdc5˓ÿ!; P EOA|xl*]@&:}$m/]]M w xANVD$-S33Qe) Àʗc~wJ eVݴFAHسhj 0)KnyBtu6C-rO}yEp 6,qf}^[ )zs,@%a}s8Ԩe'w037t( pNT6UzIe{  gq0 =B8f0Hki۴JY'x#Yw˘)o?9Y'q{Hd$5"sb ,1Y81r_qm|SrKNkO]K_¤#iE@(+^_e] n !&C'i_g)5xٛm#J}7=DZTO*KѣgM ż <[ڇ-HH)\ct\n&I0{Fn=j"xdN" [?`:F/ɵYM)Dnagrz='%wVuxwփ 2GX@+V w녑dfY/ijuSkΥIZ¬P}9KӴrH멀omxoIPRԹ?";Wx=wS*wy3Mh.Ȭ +%I칹=rZ)nun/nM)_Rax ٗ~STnO{ۧ zZwz~PSn-&VP4N(ݰ%z V8mKxFDB,=ӭ=ϖO1 ?G[8RCLamz/ٟsB!3<=0ufmuKZ8C+1FH'ځw6v _7ܪܕ8G(26窇].k2,UwmaGo2_Sho2ؒ%Qנ9"KnPᓂpAI_l<ڂ!Ԟ,~k'JU5ȎmS'auiX~^n1u)$۳y@Dw`ݼ4A KTM,d: lOy`s.~K էKcR›ÿ*29G:spf8M!-f'C~NI0^pbrP#I!60b 2R- дr⏳͌'/ ax %#C;=]!24\#<@o#o iCS҆d~ o/l|j|<$-[SW?̌WoWwΠ]HZS|i*_2sWT80ߜ;HY4TOeTYc^#wv;AtJ!ĈZz1HFn"rOI]Z.Xh[Ey,hB ~Yl_vQ 0(D0^V ԕńei4ƕͽ]Jq F3v3%0b?rYh+v$:(CRss-|/Un6k[I;rA:RT)#uCŢ*pǰ#B]\PDSa]?)=̗]yDA@B)-Qi|df㸇HX)N]I! }7瓝.h# !7-Jψ)lr%-0>SJaWkX{!WCV2SyY6);]F|r BGEO77]ܦU1p,)MÔoM|ۉԒ7Nz?=FI~'?Eu (v@g>(fA;50,rץH؄me؉qgw? Wc 16SL؀~j:ud[YTh:NȻ'+Bp0BȞ rjtJ=;..ܾe9\ѭh;V&e\ᐼj•t= +< =s- l jb XGL$wGf3HNrGKy|0RTM RDrSr'@٭6w~=}z_#wU5Fxilk?c|d<va³UbV"ұ0w(kBuӢBD7%hZ|<݌.(pL2\8͋Twv+k[;6mYrȭYغ/ԙ&ܠ)cұic2Q08DP.wX+jy‰. 唒)XV+K36ITN3DgA|K sA&ޡs\e5X!@f' 39g(_Ssb"q^4udw]*I\a#|Kͱ-qzlqr{2r wxv厑cGG+W[yժYiM>@Ka~k_Ucb8Vyy 6l- TqFvH)oҾוB<5烴gJĺi{.J6ou')| ŀ֧BɻŸ b 2VZ+ \j?ojrlIĖa'6(W3b%mQۓ{\lr$KR1S]%H$$L Y[u{@tǖַJ? MS8KLKIY6g$wTj+nAb7 UALp!e Mb'(fn^p!X7wIZrE\cxIXI޷9aҔCþԫ&ak4VHЭ.T^2&-%;=G>ֲX-Ru]e|dܖR=ab1D`ob2νN_؆tB$Y|Ԍ oCZP&jp46'ȊzЃ&mt00&D['~s-\!P%9Yɥg T18rU{$ "ٳ 铋ts6Q~΋,(s+} w:Si3c%O[G><Eĺ!nH<8FA@Np0GWlŨZ K4B6[@@/Mta;JWj QrRJEE?y.e's1Sr'KϢ;#ڝ,UDrB4B{]hT ֆ,أzg kcm(f_}OJ%C"zv*RW9yզ&s o{,"nG0dT~'%7ʝr_8H[6POɏ+\_4.r$A#R`R-^,^VFR=sN'~PS;~AЊIF]oK[C'"A 9=;[2WWXYVz ǹrk3%QℲz `7ֽz}s` yoL̿cKf1 wA{7@[v¸9ԭ  ڗQP5m;65Yu)FOv%[rx_;ƌ6QGF]guĠ<L9FXdd1m,#!WJiWMXJМ4i~?>BhǠ[0t rYc>_Whfԏ}]̯^c_]5ZrvٺiC?-op-ƹ4z5is 1mȳgesߕ4y&qaRẔzvrͰ.U,KC[w|@W kVst,A&π,'{=6+^8[uk ]G :i27}DtPhNJZc z\^847N(Q-GIԐ3+R&U3<)ɤ(~*3Ss TBdh .)>}Чp1&[\6IM~?7b 1J̔i{q9m!3VW %lL% Ŗa7dǬp֮Do^gȨǨx^. ٯt/l&]Oib]E-NL33;[jc҆'#lUc3e:\wW,~Xo <')d&[d(*WuFJIQظKHwMhuKGVm- nT]+vkOԋ{MW%5r^lбc^ O. 2 z% }R CkEZAg`B0^OEBBUkȦbpPyafֲT⚵hQY&iT1+"qqt` 0 ܜ䯽;璳[1bD|;gr^iYM=е iT9$~Gr4+7>6{^֤r)#mZ,R L<@rx{sQqM{

=aK0muB99Ï-8 b(,BQO Ml"i*œ6 M%iL#VAK8)0΂qpf;D> 8=;|u~!Kxv҈7wn&mb:I 1 @A?@D2F.~^!UfBp>뉻~O(avx8)s* 6mJr"=,JPRؽ.~x19Ue ;19a̩!"ɽ&=QV)]PBCl5'c!"!=\!yxqcqv`%*W8+X-JJuyh {,kQ;-M6jbozu[)dUëZ2\CpAneqfuAZ\T?_C˴Lo18\JzX6AםWna۞zEg&DGÁեV5aX-s 4?C~(}BP Qsǹ vJg=L%p7y*eg5TY~[ qBtֱJ7"f7q*J6E00" 0X~s4 ^Lu\]-dAG?o&C7ޠĹDXi[7-%ho r4gX(o{=␮,|W%aLy;aԓZYjFѰRe%韧=Цa3t&8{ m_("a"Zk@v*UH]Rxa]. r$|h>yъNa~8L?ڙ8_KϨǣtlr[Ƌ)t32]g&R*JiALdRyU Q罷6@e:Z2r`?&WB09r."T|fG0J&"^RL1 Ԇ_[6HQ3Nm%nUe.R^lf;em6du*zKXBc삪WI¢̴.7,9[YyQRfF ݢS<ZFH"& 01D|ۢ/e݅ .rfbw&+tڭn:b4We%MޫI4f|)R)@8Q8ںZb'=TpZyxQ}HMF_d2[2U=Jdدdħ'a,F9M%wj9+9\xQƷ 3}P0VL1]YĶ$h9/B"i6K ư`~bD8cX.A:lTAaU`ƅv4Ҋ:կ7( H"48vxAQ_|4Lx<+f*LytwۼbK_܄jĊ:KQ2W IːWu: WlqJ4y]"U@bb9ezl< ZXJ׮mEm_Ŭi% p0Ds9dnkEaśN RN0$ M2nY7ƶݵByVj4t<6YeKy6C | &0֎ /кTWэ 78Qm) ؔe4mZw8}@QAb@?zܢYot#0xdn6fJGqrqID_m2ft#u 1܌=`f28<=OĵLٰjGν3AӕkxLQAn8{Ŵgߎij W#KMfǦѼ FRl! U1;z!-΋#ӳ)_W?e/i?|m;!^i++JܦPݡ4,0K r]()FyҙARL!'zCN|DyKt}bqUK^6[ ZB뽫s bʕ CDTA{wTt$M(d?#l5' 档N6Q|5B*3$T`DyZtz43J :Jc2D:sc׺M ?-mwR (6#7I%;;Հ1]TEFEE(fR,8"52/D,hSÔjqӨ1R*'G ;Ǝjm\v|uelOaҖhr6>y\"QT-L x2 \"|T/T6UsphIl?h9 #)]/HO\`'$>KHjNpӇ1Z%שQ> 㪤;*>&7ɛ.ۺn.*9ؘlaOm3z6Ӷ1+S"HxiEfQb8bwFa0FEf>rf*X jչg2̔mį" q]mmPBN0bZi~~Yl/u:k%ݜ(4w~LYhN cC8/[n+jKC?yC:ģ(*=*8ur Tٶ7áwG'v?X#f":Giw \bLiU}h MDpv,X/ :-Qf*e",{|=~f{eZ; @cmсx bɥta*C+';fW:k]DUs^4 }n5@m 8f!Q #6`o $ɜpEʘ#d0_K2ډ6Mּ gؖERwX㯴!LP%Mw nR'.+·%J2KZ7zGcⵁRMbzj E`c&VM/J$vlX^z??qQD+;2b -n],_|r`D,|%#7*Sp#3V' ngK?4Acwҡm͉E^_ /dV id&-EkY96u<ʶ >p &31eBb^*pG #ahh!UEtIrtrzvJv3_rSxZ8)FWb@H=<+)[H _028 7'SLO{f9! bY2#- h4=xTAQFc|A7] ~iD+B6{h7DO{0+gKҸ t<ÐFw@QsUZؖ]G`Cbng ˰~#E.%Φ>9~"3>(`,r»c/w]F,c6x+b*M)21^k~iZH\_9D9ŋL0HuzEh!^=,J̃oQN`] |,,W``bmn@+;L !IzZ\J2l8CP5'7n~Xy]=sCη|3H UNW"zbT8l)<)%-6 G#-ƘN>TDۈ/ ꜻs/!SgKTxODPb^68Q"KFñ_fp'~wpF?a5 _fgzoLtT7?BKI͛[Ic,;'pbvv^(&cM΀VslbLn]`VB'WTHYo۠{AwU0{ݕ$^XĈ(o UT0Q:UI`[qħM@]y6m[n]Jf\ەK $LY82Gp'M j EEEBINaez]&؉!gB 0lr5܊6^|qШ~hfC }Y q +raE|:QCN"Fs["GI!FyYХEHY(=:U*ONi') E3L2C`l&F"hϩk-9Kg8L5 5^RbƊ_ݹY;9 a _=nd:ٙl,w9KI ' KyG _h>`/k-/>|S~w.[ڏ9 M)ʍhKj--ɜxnew/]s;Wז+/0{Se1Jt(n i۬[IЪ/]` <[QCϜQXK)&Rh 7|c`h @\8[wr#ɔAX%Neo_сՋgMO K@u KQ~O8{ /` zf*(&ܵQjJEGAo.^8"ȓF gjJuZQ<0a $]zp,`v|6R,/L>F$sDg"q&;)JTש)KZP9ʀ ECLE49*Pz5궉TbSS꜖sIaK`i˥9N/j^H߉|^  QЩAt""Oqs$'3e~..p}ji"vυ9KU*lBeOsiݵF"x#h~'%d]'!p=L:Yy5%zIt--į (#/7sU+l2M2LN@`0giunRJNJէ;A^kZ+L\=5-IA&ئnOwDEдk1"K~ Y*qh."BPڒߜOب&Pr}j !88ڴ lH5y3K0ؚא$[l8'ӵڜ EizxAHc*w-:$$N 9N=mR*$R-ȯ_Yכ篪-ʥC绊1}'91槈".!=Gb}vVDGCVּ{Jw=|}/S$Yuy{$BdP/UZZhC#8y4䎘KJ8mmTwbXx[p^TN\A8lT_#2gCoĭ[ո{S A3l 1sY \SJsQLeZI[Qt-<h3r=,=%9?@" Nޫ~\&P]l`)3|P/8(hv!s AQ &L[7F;Q6CăQ]U:ʯ:"S@jjuq~ T2$YO|bJIAG7bZ՞qwğ~6nC9*;MØ4YL߼c[ X߃mm(;&ݹ_|jCm눂#墍 M5B^^xh`[(\|, vF(㪧MRL.&sE=m02 gLȁ"g>uh*>1E)("?{~8\^HJ3C`5t/L<6e;ᵊ`<I0 m1w {lz! z9n&cB!G<WCmG?~xN%"N|0 ;.tsO)ϽiA.(ZB0g򥮥ܥ^E[kJfNrcm +8”c%WM{+` UUTy*2%un\qwp"Wdjhj1U` 5l{Nqչެ Ŷ+Sc%F@^չ7`4^xtOcQwZ~S c=0@&*]8oCmm&ˌuO2u"ǔBk 5wẏPQcij3 ~iVkhai?!zE6x \h @n,zh ER=Cq 5Cˆ+u59m2#%}nBtme񬯆 S>o^3B+N>À=ϳ%puַQ;cMk%*QYL,moݯoh%r]y%x"zDǯOz+2cVrޑ}K*7o`pϷJb#ql͏ZfN<pє`0Gm'CV-JMX'7*~ߺïn?|RCmfOgTm`THj tۙ jũ1iEB?uh]q7kT3}i0뢷FE8Ƅ垺]Թ4FOy[̪6!!mZ}; d+HDdAEs^kDA2/kw^jn"fۖY+=~swy <[Cv2}U14w fpV"n[j稿r=".j@L@X[} Gh`v}jALuQhs쎲WONi1C-MJ9|[4=>+$AsDB+H@#Um4?0|ܤb]"%$0OCmd=Htg+oɫ^ZxD($>ޮl ?SNr.;5ӤU ^wܰ.fzY"`rPb3;ø5\9&.X tCý'Ý)ȅ~ւ.s)X٠PVvUkO ;,EӜ6qSކFJ+.6U58<=w66#ͣ_Q C q)dw=Wyd˗Ʃ 8D0;L0Z9py)Eda>0*UP(tXƺnx*&z0TYPuk kk\~hgUT1u)URT[j>UOTchĉǓ-^܄|BqL4tFv(C;!3`fvSNeT)Xmh(`lQn+;3" =qߍgF2j<:AP\zq7в{R;iVv-d'URTnѽ ڛ#oRdG+{E299? X铏nnp7@#z3R@cnSκTt'TT2 p62vTW$kHGMuYBt]-`6pp{Βl.+S"b&g^. 3OsbzfE _\u]IX B1>xI=ɓNobĎ>YRsLqC^PR/P\i60h؅yڲLpGN0(Gf3^BzCRA"͐SI=}/ oQR8nO=|gYǶVB! 7`0i580u1тn`]eO/LݒkڑdJQ"@ @]4c?_89͖Ha]~^IQD~D SjΚǒ[\Pe~L{N(~\̯S:Z``{]Уa(~^g)o$ / 5I;q`L!e&FlƩnà|0Vjf}Q෹R:Dq 8>U 7=+*9U\LD_͌ cl irxi_3Uytԛ|q5(n,@?qơ]7UlcػNXK%<$o72>1xHnCh6zq N38Xʵ_D3rkQE8*ET$*2ڏe8 i:N:U22͹ؚ1_p2~?9xZ6OT$u*%J]VdȈ 7esDL6u^iKW Oz7Cg&Jj LI-0oy|"U!ӊ:yJ$J*`2{ ͮ D xyLR1׏ȿZv\:2@9-!hIsUSY.\!@;7_01Č#9.k)SfK>-fm^B5( ƎBCڴ|W\cs@8F;hM?>M Z|WZZyvSȚ$$_e0h|=bL%|}8KR@V-ے0 url Ln y% $C5 y43pgq}˞&=?[% YXvK|C>)QV,L+=-AE㰞OݨWq,шmANa2s5'/X?1wV ziVcG>;)Fnơ]BZF2PwMe'_T7u'oS\"pj=wMNГ:ɜj Wha(غ eW֎%2.X-d CTqHW;lO~\E>ur+e.tD$`g#mNLqWF-71Lj g8eyk?L d?( _6(@6y#/$45:)?*&"|Q]1"{.&TbCաdz.&59, ]ET䝉L ]c½l6RNYAOkE0u7ϫT^_DOvR朅K}ݓ!хM?;TV_Ԩq𑑴z!7Dkt8Ő;k?`)P0ǚGǸs]fGpssĩi"Z+ZړZw> ﶘHxk鶚e3ĵrfxp+t!V#g)ђL6t04wk@E-t<: ͻc#8jҍ(Zew疓(aZ$5A ؖu#r䫢8WP[Ҽ46@T/ɸNt5yX3}٣E/F{e` +/VݦJ!W x;E̻~C)'pE$=<9Uܤ8\5b'XGƅD|ǻE{Z,;fptI"Dz*Ti bq+"V%fRs=ѯ[ٝ^ng6}9^ 7V;{IR3wRS6>iG7ͻ#01Gwqh@6)MsY%y1G)^H,dʄ7xX=h 5 \X0`*Rx >lE D>tl[#R@3[ӎe'bKi#]џ }4k_Ϭ }߭>CY4Fx-9C}늵EW* u֚1Rs-Q uZj׽ >eU9˰iz)y 7FGS[h@I<$rFfM:Ӷ)l`D]#zdD˩\dFQ#pNu&vzv~l9T{IUsϧDp?O _ jᘿju*f#pλտv "F zsb;axQ[@6ԕЎ`lDuчr z}cpJHPT9jZ$.DwOEsl|})[ogY8ZwZOu: r>D6Mfz)ϧo7HvS *+֬2&ɦmn=6Q7$]ƺUNDnHPA7˨*7ȶ#Q>w}Nyryin`U38SQ餖z(AίQخ`uW}1L#Kf uK> Quz FXZs^p߷+|';fhۓK%m8\w3E/@|),4$3G۠ovf^` bdxh,F"|<)8U_FrRw|`DonHHo 3 nhcDQ{$pb0Th\`W"d/ci^%v(OTAj ~+߰/4O {+!{+IswXwxbh׮-ۢlX@1Y|[ 'R]I0 Q[hu67CՍhGN3n T YQPoIv/sUW7H~Qqv2j.nqsa8(t}FzӲK.]c6|-Ӭ)b3?wNby m@5'i8bo3IhLOSoGPZ:a?s?^ͽ~@]LrK59;O!㎬"C&[ u9~]CjapZЫy[ [ d1VP2FٷD@&wOɎa>Om(*m9 :XSŵڰƖTU^ hc\SƏ!MmD/Qw tq@Tg\Wd"E@KO?]NBobJj\VLWN Aлb ג"E/RW jx7bNeE8P!1,PɶG&ǧXq ?|Ani oǤ ^|wc:{R?kp mdJx ?賛q ^0``+zWod#)(wɆ~*5Spi1UbҔ tɂ % {ߒP$t²ʻHO#n'؄ Z>$2j|C7_c]*/FO16*T>_>1d@8V # Dр6o ^UwYsj]F 2QܮKN@ W%t-R/D)F yN9UIq9?쯿$튂e,? 4.ǃlrpjpqxǒay6 ovJf*lqwx@mC|G2C""St[v|^(QG|;<ҬG'p<>&nWs,g7`Vw|Z4P0 _"I'*}pIO!L7- 0Tk+m( ŽWŨ]stXVY?[vt~4LT&r뗢:DO? Y!AFx9=qW9] WIj(egve;r;fLynOtE @`+br˯?,̡'{;m 6)92 bŝp(_OD4D6O1UՁu{@ww7bFɺ?#(>t*㌿n^IRBC!..IB̕׾0旘t0S$s.q] P\嗑hg\@zON~Wuhdz!i޷.ڬlՆ`' [oΛߊ}cS̺V6U,t(Bs>O ZMb(@ 消)=xp@P}*XffR? jݸ.@%t.@|1bx(e>Tg626) c~p#4 Uu_©g6޺`vK-MXEĬ̘QXaW5ͩij'(0Z)*J#tGBa p`@7 %OһG|yG3AF A#:"U&;I},*_W뷜owhz{IGE9kҵ2ϸ'PȕAeUlsNVE_uCymGz`No4hO{)8+R⏶N{V3؉ҟ+ƣb(2OA {e nт]8rY+R=,chDg慟>Uh$!e }oNG˼:A묐s=}1@nC##`I>S|2tj;[@B۳=$ܧ\ Δ ݃A1YT}nhUy Pp"FT L`&šQoZ[CvXQxEC\$iB pxzU<Һz^W:η+*_Z1 U@Gi]sLs^WmyKs#^Lˮ; VГ OA;]sN!,q9%nX#/&XV.-J1:L)X_7g*/uuN"UV*mse]NHOPͻ`6Y\@dTo:Զ\ t%ȶ]f:͑ag<BK?Q־r Mؾ*! MMʠA==K ߘb:Zv2Gi^*͕@QKZː(1*%|^蓦b"B D 75 8e~k]B&6`mf[]\>}vۺ)wS"~'_/UnVXs6L-/6NS>,ԝ\51PYMkX0Yrwho:L"V9J:勿/"~By80c&fWM&w9wpge/S3zoll#h_e=n1 uКmq/O8~P6w]|Geo©l6=2]> rvf@dABm,pZ#rVƥ}Y5#;ko]f$XIhM%ЭzuζE:`gu>6%9ON][qy'Qa1O< V~sΡ:jG:61!kҧC "/п>Ty_1fF,v0P"_~Ӗ Tz׵1{L?'H2A>4<9ڐYzxZ.ǥO_尻7Vt8e3MfQ=߇.y]`iDqz-qs7--jS/= =KEDQ3v qyrB7*v,!YP {wf^%Dt9[A]yv8ٺtك_k"M{ By4ǡC"ď_vJĩ(f_nVyްWYCL J {bH.ns 9nגsz Dj9='ؚRZEe_.X.F7t 5?WTIpiW:bׯmOadG3 N!iB@Zt._iK, IsT>\,uDMfgtͯאy)oB9Q Sjf<\[ֲɟkV.6vUHAYod:/G6=Mq4d`ј8Gnl0u~8ww)~ehTqW'@nJbSWqs1f;.NC`S / :! M(s[qh1vy; -͚h՝B!3O o[x2Hvd"/1@#Ҫ<5SDB5O!ڼjNdV;@4%5  (XiU dJa=at]c`YDl7h &J.!̼.ej3 =׳TCKD-?VŢ8`^O;OӥGkF2*.ӡXE_[~IjI-g NN}Mn&H.b$F O|i*l˲OY(⫶J$;y'#8]Wo-Y7 A|AA ). ڊo$0.C>NMۻ ~?g +"8'j +N|X]R'ٯfb _\ q&<7za#9t`!{fRX|Fpk/H~k'k@=YQVbo # /MR zO8γ>0gjQ+?*`J,Mvf$H"*}EN|$!eݜn DWFɪYЃÃ;rǧ򪂹4@4gZGl8̮`]iUI%x'R}SŴQi܃*TСt=sqI#lBgw:X3\;J!4Y:8 ;h JGm-MHP'COpmQyߔ*M :|U.)#g5Ò/_;eσ>bss]h.E xTW\1c}ADS/ E_{ Rk>}w4VMvcBZiĶןEôaU%ԩ(ۂQW2 dJA#%awW߸gf,睈ύ T󘑴 ##<ܛgm^ 7]DMr` ۄ6bBVT,+BM,SFQg4jEN!YzڳeA 33wBA32 fU-vN+ t/"_0N?lǮ"]N9܆].̨!Xb]KR ]8$ئώKgRܧKJ9U{#ƄƉcGd0"o$j{fL4ǰ,Vb,B֞eΖ&RNvc@@_,7(w[>i) .𨾌SG?nwC>t[,ℌ|3wO+W,IjW Zv]z0l%Z֜%C \˳su޹{)dcu|`-D-v c/+^DPCRv$.YפW|^F -*b-0^qLq { ͺ3;ޖs/YT1zZd|XxPl׌BYE#vab;pҖW& DγՄJ+ :0Ui-^YqOyW6cۏY2}F%mQꘒy "= e7ʰqrpR_]pA09.#/b>̉,bxnb2M@5"G u c>Wt_.B&{kW53AJ ([Xp>4R }&P/^4*;L%7R"0"vmIsEr`b1cJMP Tu$6 *sӞ(&VzFг*Jҏ=WUL"Fdx%tv-V={y!̼ؒOC墵Gi[SFT:ӯ%Yh9vn$5֕kn]'ciMNP eQY.C=eu6 1,Nm"2Yk8*%Fv-Ɂ#{6s B߿HfTZgw1*5ҕ]p<T"/!@"]u_A7Ӝ`s'6b@6eT8G3 $eHI(5DaJ@X j[Uİ9^'BE p=C3M~դm*5dEr:Fb'XPǜNE$wJ\8PY.;lvG%g4K$-BH*P;p$8'UyiN_c;6` DaA.O  = 3/Ҷ6]WZ$՟B~ƞvΘFծ)#lJ7<(ZT99\lL(\ِ")ÿ8$-0b._H]"I_;+? !de\_ k3٩ߩK_5&qpg^7-ܟKjs:8lsU#RY 6LC >9W7cЦۦsWBbnD"ز9;®5=<o$Nf]QD[tא2;J9e}=}ywvϚqP3?ksz &Ք~ avaHe{N#`:us|8_jul*Hw_%g>W1\&Waq|ww}X)0V v?wSv>L:d=!)`1xNq'4eܗ8gsi6Vq7k2>}T(f:Ǝ<C,2Cg$m}?buwabn9EW}Ek"NOx!9N=@)'|a'Mvt Sp0,]L3KQM.L6F/69o6y9V(z][LYEUDрݔ 맡H;JX$->UrH] ovjqW{E=˯8ix~/hQ媕Rˬ:%L(% @ݺ%6N ]D>QV/';ݴ*^;r--DT&x.WQTFr\>*c[ "ӮB8 [;xM}4tUpv'q؃P Ï3\n}nע<2?l(EWuW90O9KyR!MMxrXȳfXo6Wm!3 mLA0Lm@Rb? &< v?DzBX%9k+wsq: =\`S,/ }rV {r.5 ~.珑݁Ꮛ+ĵBo&/'&$iKv"b=?2U3OE;Pn:f쓙xr06B1(ayL1v0(IaՂ*y.WEWŤ^M1<0y JV ppv]3*f({}1Հ_,ps9eC C|2l#qe8p @7@EDRA݂ٺUleޯ?MzUhڰMvיʸ 3fFtB[Q69,5N/-8M m]B֯,iԜ,|:OVKgOB<5,: t@kB?-f՞z~ # %L LuNLp &(2TF癰qvkxt @٢yҰZW:^_ZYOHT&!Y6G}wN˖PǪ~!, Ƞ8v!̉yTP] 0j@1PxuN?JR_ikYbD1zD 5..s8g7_^ m|L:01/| [/&*$t<_( z`0%9KMth91y,$s}.*{$om;>&p{fr&:GOg{%t%9kfw߄;-1yBt12Uc6+^ zPVn}VucXy/h@#1rc`gO2Նюd@BE襑J ">Qύ+l) JUbՎ}Cb1s :'&$k@Gp-WL `0A[|V8ο͉KFmWKFJ?.eQ3A6N+$`voq,N1wx$ԷXQ'F~}|!-݉:Ͼ?VyT:.*_Z)T%m!XL, J|9kYvCWlrmfi1 r"hZ5H T]D۞IA46r^lj8"ʞm]6#h:ea3&9#x:Q)l+ N]vyGg5B:'\dxxmVzu][`BڿW?%GfDYm<'(&$@0Ԃ:SZB/mrkx}Ew7Sg4h'% օrU҂=b8ĶI6r!5%XfJAs-RUi]LVK t=־)t7DE$-vBdm svc>\a%| .W9rAEGe/ &x=lN{Ji ND/BgJM_pV\*(nMJ(C'UW\'uE6hcUƦXJQA#_&o$ڃxSwkQO\>`^;{1RP;Xy@VĀk{TrL6X3y)Q\{!ن iP*ez+sN3`0CoFN[af㎇s By _m{x@Һlvw}[mά(^{\sAtakjVOݴ*\`? @wQ׬o=;jPHc%x ?'zT–9P( ͋4cPk&KmV,Gټǁ"8٘ R9l^ 6)«juזOK\W֔[un"H!ql:9ݩ-zﱏl~2VaK_2R5hZE"4M8H}q[f)j]Ѷ1\qI/X"Z]ش0Tdů i,=rhSKufBY0nߩnQGW^vu293bSP ۫G}}1-N ;kgvP4 }&6{"e*0蚑N` c" F l?= RU##zp$qX.>`M ul{T`RM%C~~r.Yw7դfL!̈́·%$lxպ,'h +btȁJ5΁%JJ:o jS?XIi(lxe.Cbpcga ͜VZߓ}dL4'6l4xy*OB3f8B+/]*~q:Y4J1.5{e^:.hG2fQݽ~"DhjM|?G] ]ȻzXn6:^\&S8 VrOn7"qXsKgN$ٹ)x~YR~᰷|Y4g SS6?Ոz:cg(%fZIb^G)_Y:rNYN_G[P|^k8<6C1 MIȡERf{`잲4RKVn&W2tT/1\?EsyH[Lu(8;AI|sR`--2QSM#]i%`yZ:>l96!kV!?p &9VEƯ8BGzėyŖODпr9/C(Ѱꖁ;Ԣf. u2mN1k}{jK @iPIBޕ|y:9b(8\EV5{讪<8f{kk0`oQŘ7_):5cӡ9 W\1$n]齲ED-},ɑjMe`q6ѠsuI"%CB :YY  ޢx4)r "2 , j)\Iv/5r\'ˤr,I27wR*M6֗&#+kô+' CQeHD3 m}WoWD%aZ*Ӎؓki@YZ,i,Ƿe?((ݲ^9D+3?>xvh|1]{fho2bQ^фaFT(Q g˓O+e*v΍X{mks 6he1~+kɳ#;({9}^>JGTq~orwҫ*a:Y`朗U!(~Nۗ2I5 \/ v6c&@Wm&GFCyD$%3Cn;W ,BE>q `kQ'W֫f˚ Nw)ʱM|4㮼 ?bmݿYtQ6̿("ֈ,\`:wL ۵OK]JU w^-bsNn0¬ 1)|ګ6\.'k%\ZE^`, 9욋;KtkmM{8F!L4W݃y^93a}}`2 aMOa􄃳g 1M ͢7ޚkXFET:+ bPN*sb$7,nXK\nԫZ^FLypjE(6 Ke1.!Ւ)L4 !$S0zJuIqklqL"/f)I@KAg4 sarEƃ bzezg D=iU9WODjͥf㲆X1]մJTHo'61ȯ0R&dˢKKuɋ4^Gz-.|0 -@h;ߗL?B;0C?, sl(a\[];݈8u}eZ&ɮX6 r~rcKzQFZtDh1pSrmoÚ9Ro T*#{Fc'Xs4OqYӓk^nC+$(9J+꒸ΉNB%Rt}E {smj2È]~*Wqqv0jD*wzkyEbWvK V/Y<9amgP%u={eyȈϖUMrALK0 wOWnK7|`s1e_-"h$A4$KZ@Z/3Lnf'4HMfpShؔFd;bv_,Sʂ;AX+d-vJSOuIDh6CnrKR,D8M ,S>}owcXyXD[ȗ$hWh\ԶW%&ͳHcZ/{Ίu_:覱WeOf94.L~B-+hH*5[5Ts|S3:2.ۂQ yS733?VyÌRY(yǛZ)~R'~Z@-0Cg^9J'Q֙@G-f/z10dpL0AUV9PDã.DmwȉRfߠ}t?;N2i]*!lI=pu"XnKojU({aԙcՃr9q!_gE fzÁ,{_>n6p^-uR[F-XwB?(eB)j\E1:~f5txRpX؏!nenj8O%H7*)QJ?"/+SZ_e] l294N¦%mlp%__d4vsTX5Iz5BoZG!qǰo=|(*ƩSVq;z,ԼH7iMtVd흔sz%lTvcO4Fپ1P c.99\|! 7 @59O'ybB%'Wm o)es 9<_e yeae=f؛RpM N7?&v44'\I[ڮ5_-.Ly!0[)rj 6l -w#$;=:a4p嗚 |B0IТ)࿮nUrr ق:(ZKNa=(%$YIXK׻+CGUً P9h@G9%;q1* >4Vdru|(O )XQ/Ou~V34|) nƸi-Cs)(!~8* i"uҙ^%͊(CdG_Pر7S eN[j، &c"` o8aۍ ;B4edV&URמI}e)s% ^9,]MBAX]sj#=o~x(+a;E<1bu$;rɶDJD4nլR[s5͛.œGYFM#X@SaQʮPtSۇsA_pB:Dw:@ YTfaa/ҏez]@Yj@*0?zo3%SG'>Sgu,o iMHnhl]^7ySH1Hd!Dݔ!¸oTBp䛅\aQUfap14ܨcpЕP`>F[8#nHKMGx/:T3-hnSQOo2Ҏ@`EY-tykTt$!sX/&ܰ2&9i7d  diő.zUZWx|D:D;vl\va Q1˓RZ ƿؗ"Oٕ("()kSnSDGU wyk_GGQ6t6w .Gܤ, fX.pH夈}pENPOr<&jrm}'A_͵5FQ4a-8+Mܟ h~᭜xְ P7ٱ߷)hy^mǁz>-c8Оd ,ν*6 /Y >to%A|p1M%;)F>ZVSٕ(Ux׵Hi>=m?m(1nWV{rSSA$Mכ;\yz}Tڮx2='):|3ne|ՃӜR J l^"Ϊ VjGAT;52BJ9[踂Ҷ3#Xd0^R^XPN’״y㭲K0;@pe+440~NvwCzxk  ON1B P=E3IObGuLsR'w\߅_-j"RXeSmf[h$Rh-|t?T'b]~!Be^u0XiQ\n *-g _uP7<Ƀz!n?4 /d6cغy~R`,h(qA~!/eBz'%N[Up[0ĶUkDX>`3Ƶ |C\lhcfvኂ&g6? s=`}=OhSth @ˡzZ2I~\{P+gШkR .LI(=و=Ԃ 4##I- .|,"gI^-sJKޡ1Zդ($L^7,p :lnJd aB(UC iyDBM kףܩIj,K7"+nѝ#FW{&oVǓ~͗m0i- Z) 1V-(jMcei18ݪ4\˯AeLvOb2UR6@Axz亼$'x87hZvRj~`O8wsoX#3lJQ îPN[GaV'r0 f;_nn~$ rlZ?;uZ9L FQ#D0\Lˀ E GO5)W v-IZ"/Bu% e],YUSYOYk] $szԈa.LHyZPjtO^C >]l,mrm/`w/_%Eӏ[7l,Z"EP6S`E_w`1` e{W;ӆ%X܉.l_ A^ɏroҴ9rHM(LHvݨd"0kz=- {SRကi|<*co+F܂=4ƥ*̑W6ïȵ.s Ir@ؤ(ZC kk{|d0sJX`^L~r2sg`e[ѰrDV}) &{7Ó2V_(^..|q<fj-o쎿[K|zM,9Qll&"+qMFIv̈́aYoU*5.~59.ax&DK}\DXT^@9c{8;dtH{Qzuٜj:si.C:krڢL>X_gh-xHzT~.mxw2W8>afz{w*<;Ht&l:H4a1%Mgۺ0#fdH󏡡!j'%/N}8GN Sd}"hSs^o`yVǬ6 h:iսU띬_;՟.\D`SY^[v׳_@r^@cBtڌ-l8#{ |ox.PSJnAt놦IF9nyRb8o> uj\rJF>)4h@%;R2*p͓;Йw~.T3x8lFصq?G94}ԗAfڑJE(nDp3 \N`j/z7GEˑMKl[\QıF컌}䝱z`txC43s%ɟIt/{>ہ'YkE5H)ktS;K.#/L}2bw,*ҲRmcg/õpꙜ6 t7n.2,KLo ~} #<[r.%onu y.YHÆ+IHqZIJhO6 ʇ#nNKW*s%+]=dZ~؉+6 Όtz Y@XBM((37x40t|páť:T#O?:q 1ճ>LK(w (届}y2FLd sMQsߌFqBj-8NrT<.62akT.-> kit)jwhߥ #6Y+8ԉ AZF@ْ(߾[U2e.g#7#Ž=9/2mj%1?X'knZOn4;s82]EZDǵP}AF!txm/ Cz:JfBJHy_cVM19ԃ|gJzz%P5X4W rzN7aWQA-$[ogUA3xQqB7z0x\fl,#0%rt Ft@a@|RaKj^9^ǘw'6Jo(C:!SKD 6>=ItkA'ȄΞXWgAnz cՠ UߒK8%_[O }mWdPHϖÙyfC=AHJ 6%RۮSO r`q %#b(-YSs6kcpGXWG F%c:L;Y;<!܅Mƣ[S#ͦR8tewH䢓K3Ss#fi w[ҀM^ǚucTJ,4T//6,)O S)2@d,9YwLXaWr=5GF!fE n5=CFL;2v2ACaxD5"7 ,`NRLMʶ dz$>~apf.CE 紜ʈrRE$A>ĄsR`J(-ORHL$buazvgEboV,ZbzB~_/`ύ>r"#)Ё}Y4{7ߋf sI%ADƿuKSm!j?KCFmC-L1q)>w| &L%2$Pa# IY7Ƞ:C7YN.T&a'W_#3C/{§9s#! DYP8hdJH P2{WlK[5 L ͱ?Ճ'9,wl.X+~~RM%|Rc=z!xqDC(Z68PO_Cius#Jˍ70wnmbu#,~nswY})>pli1a.Hο" Z3n^O0ZpqIQҴ1x85^L "1y'u4T_ch*ds+抠B Q<:ܑ ח ypMsv۾D(cr$ȓIr22QQ|!}DiSHrM @ @°X f/wrĎ;2^W8:dzC Cb?c52Ӱ8I1bZA[CDݘ֬,djF\vC,y?q!@AzU-=N UGqόCF8`Rf[B_4@k+?x)$D(؋cup+ق94xp+hGҠn\v˛Ĉw%M&:Ž3#ҚiYIM* RKy￤؀bHuǐ@nȅtEޖ[ɛ6h<~<RQ+A䏥 گg^ QW%~^z(MP v-J`}4@O"9ı#xf:OF.ɷu[/ p]K&!̀"㉅X/>r]Ů T@NtzrbmaNRR98Z'3]Iǜ{ڕq{R>{]lGaz$H~"m!Fs!w4` 66[qy4-<֖/>'q;$<13$[ [P^gsly?,cU'*8KZ;ynbNRh&A+;܅,,<f@,XY<"!Z$u/F3/8JpQ6qeJMᗰEk˔#k$Ge|m.!\ęE&_FXG-tj|RLvc戮^ O\X Id?*-ON[7*KR /]JTB!q4'TRq='qts˸Ӌ),'ݲͬ{j8%KbK00{_`(uOFâ&׉:vqes6̐^1y}&.Hn7bZqԩߜ(*Y|p̟|.w'q!Uj"rXTE,[G`H3on4-TkLCfTn8RdHɯ^le\v5t׽f@S|׎R-" [NS "axy#o,SÃU?ܖNZXMwz¶pcyn %T(V'"uR? 5z}T)|̿W !%D&|"՜oj=T?A?[!́}D/lviwf@?[ېH|TH)}PU/>*ȹcJ|4N0y-HTה%rGg3p/}*#9:'侟h^CfOKv5!0׵9.QISQЏ#g/03z||=)&_9|M5J5ߊ]ZƼA6\R\U|)Ez]ށ$ʉUc) Iu[4# N)cJB(1S^m *?ǓԭX). uNLԐ<ZV5#~M M6soz`Eϰ7ui5Jhw\pM)&ƌ 766O_ĈKtP0?։ !*SI9ҝm6SŀBg.b dYk Ce`0԰?|W4s<2ᯟ{0 Pޤ05򱆅aȕװ¤YSvox56ج[?wp\קx4,@*|E!itwm|?4v iMp 4VYu/CI#ց5wMH3yipYFE:C=菘:GE7tX @z~Nj׿\c V͋ސ]xy|8'QWgSX't;u𑬜=f.dD4^Uӧ1M}KYAZf<{/|T'|Nr. % rpKJxx*Yc"!'TcK7yPK˃W`{یꜼ^:QB’kievh䤈Wj)&%j%rұ9ľ3FSmfF#"pak( TߒiOq.9M_̏(tNc>S)~r=lm:ZgS;W'/G?צn'H0K#DFA\]Xj^aaƣrØ?&VO!`^ okoHAb9\q{9,:/39Ej]!gY 2R>KL'r z7dλihmQyF~F I&fޤb鏷e:Þlf86[ɨIlOpt=KZtŋr cxq(lp$<X/5ѰcE5X[U7_.gC4zJúlB.auun8!ZkFaA "D#{7AsV6˱ǻ*>iẐ`!l8-Iz_g r0 O$PE^]:Bs`])j6V_d*^47*r('So ؕo)0aRagL'a"0m%Yʊ8/*rdN$o]uLԯ#UI&VA9Gj_aʥQϜOC&J f |mM;n=SȲУ}{in3 J z{uVoֽdOlm;\3RL;,r#%[WϔC1c4RMb*[ObYt#a QfcύE9 r#N׆{k'Υ4r=p5 |7PEs*Ljׂ`@S̓Yf`#aClu jS6 RNx6E={B->M0RL!̗0$k]r9zD l`gbϜ3FH恨d8ѥ֡?dì?t$ˠziؓAn6;|_]e 5ۦ'^*gt{!4ܜS~26ė g1?MNKeK}NDNjdh{^noeU7 $nJm,"[J{0b5Ew٣ɣJtv-'&`qkW}R>~>,^' .A`ʋK^r= S6YÅ+eFd֏`e9)t?F.\_l9"Uѳ޵v!c:@@x ot;CE>2אY)bAJ)8"Y{!O+!:߰UuEY^7Eġ2اZw^Pt XvEF eA"_Kw,vԾXcy'\grJ4nGi^1!X1I t{_TRVn8c8}Sy&Ւ3CB>ķVZR_|e(vXa=pCK]S 5;u Dy8&@r &ex>%o +xcq3E5Y&*  ߕJx[`%` juP8$pXq+" [FDC?e|81V@77A7eYR]83{@BLH]{vRΘx"ʦXCǍV"p5p >>x%0VYh}o!"e> |I}MŶ#^cOK,lH).r6q 1خ-֑ab񕆂\erJ)f-Cn ޸ ˑ pwnmEFh W6KC䔨!EO4*O4~E㡉kTz^ vy+JU+lQA-O$Ls-B]U֑O>z~ԤeN9,jB \t%)v)3ylŸ*\%bRahF-| @[}/xP~1m(Wb?|ǎ wTíĬ쾸πC|8@͒G؞ <u&&Pvl.o_bVJw@i(HEUVţ)ѾoUYdcH@X`% 3j=Oݪ|.gM&5Y(P@ש29g=2k|$nqBsF(m1{^3jTȳTM//8\ ~YP-E <9u_V0 k]( Bf(Jů% u58JM-wp4;^GjReTX4 8^/nU\8=+F&DBBd l,{yw6fд O6f Mx W;4#t&̱ʦvmnW[ONg \S u0] #,WuͽN(;A8T=/K]X^ ,ag]Θlb{a0٥bA[(.[} )xq0`?Ќ;'7Ď'8P>&e8D҈隷7\-Dm18e OxǍTV|$ wUB~xKJ%edj g*F7{{txە Y./޽d[c نߩGNeDiWb&t"icl&Hu 1&J00~c@p#m$+6_<=YmV4@^+) d5as,Xr$MpLRO:U kb9z,4Y@2KՄ][r=XBjX܅ɌM(:B vۻ{WA-(ow*Z=?>oQ޾VRߤbgAJť5uɈ:kO_~G>G7J$#M̑rjb9%'ъŽ衋'#*bwB]XNHfq-"tW@6ܵ{xVÊ'4xA~U'5%><8^ 9`r2/p_AN V7}깲^pQgk&O,JnrNgl`bY<8G%n%09Y\iT[HZ#5D-be6O3sXǠcfϋ~WY1q$|J6mȔF)8uOч"˷h.S |)sωosJmHb0|]=aesPcwʂ.Ӊ+W W8!CR)׶WSp^Gd%Q+wɴ獽N],󟥡9.4ؙKI "i'EZiR ! vdu}r1ԝtX,v/5pd8FRj`n EElˈ0Ade j%Bd,i_'oTZ q4 _ }Vi?j[)} )i rW+(_KVX(ǵWkxVo| x-&S]J _BeREv3$F5s`{ar}L8RF_˅jӃ5L]٩gBV qav PO14P\W:g2ώz ፬>`rRqcD4%[0i書f7s:+* ^C—v!4)gPjv(\+ [ PRoQَ /oThTf Vv G swɀ@XP Qcb.>ŨUPwXگ|x/TIoKŋ٠aWG̗QT+`/= [c7N @mvJtjWa^ pHPYYLw+M%*zsEYn} ęZ; T ,ByoZ|V1 ==(0?U:2*T[7U2-GjX;u]mT"އ{Ps0k="tAB򇯭i)ہz&Rk!r,) YF ŝ#S+ٷ'(%XٳaDŇpjG>I\USEEK93k^P3baM'a: DB߸t-脝3>Ǔ>@p˛t"1K'QhX F-is0MߠgHjV$7H*IPv%R\&|ؗw5*rzF+ȑ8Ѩ:&iy[fAg cvvSsޫBR,+vxu\ 4|'i0usr-Q3]}0PUxc>ZHglsQCpMu$.0bvFA_ו#/dQP=w`_6_a+ ن$(zc7gIkz!EnLex0 'i/g[QSlLw\ҀhEf~p(Br ^EmO%:+^wFYVZΞP8|,IaN/l]TyS?X)"vAbeGs(j4LĊyyFM.D orQsap@)@*OreJXٞOym J! &b??>sA 0oK%lh-,p|~ayLO}hA4awKL@Hb91W0e~D  tf_WeQ(/vʫן4Ѩ>PhjXSWU[z5,r=J~p#Tʄ=صNW ^KBx>z[vW~>]ɩ&PѫPhX~f}ÿ !NHzQ 5kZ{ut8 AJo n&4a,'сep]:9Id*e{JsnYvp1œ3h); p_Vd†(m=vdLsCl{)u^&nN) '+Bȼo]Lbƽ}"IVFQ[&ģw׏^qS+Ec,8)>GSiX)FEmNE4wEӉmP%d|K*?N=i/k/nή>$pjʳAtyPv|nugv"I'"+J6ɛ>k0=@sp 8شQS,'{Xk^ 6ָޗ'u \hkuAZvrAWٮ^7}ٺ%?+nWa89/>5ӪM@M|eN#q_Wնa=xj˙&(-s"}gJhmuK׽(p&id*kUB)^_ Y zIv(9~5R8)~vb?` /sO-澋t܉,V夽Oi1D%=d1( (OTenzGﯽ=xH1XcüXXƣV+zMPsUm'L ME@Z117j~/DuSQ6Y`׸b*eCeC'̐k!N\WBB$~QwYMLg0+;u);EY4Qc8g։ϟ˼^okRldjj'0Ї-4`4R!N98 ,)^?"j;7l;QJSo$[߸7 W>/ X̭'j&Qmph{}0z ˰o'9uץC0XYY:k$eKT v> S=BGaR~9C;\<&mcu5ԻKj]-g(x3 ;Z 6_FBk?ma$} )l7:]CcH؊1O9l *2Z cD!<Jc-#x_@HQeD.ǫ(*t#eS~wmϊj :A-'Hd>WW?uNuޠrĦ̻[ 7} ɎROk\X=9p)VR2e)cpl߸%kgL!1 ̰0YP~]IΊ$LƮ&Oq|߲n-|ˤKjԞ)8.͆IkݨxDcG`P\{bXmEA@qWd]4m;E׀@xN(E6=S ciJo A N2 H;]yl֡@tWHQm6^!kdv M~z 7Zv@ y,GfE~Y7]2(X$yC}["k.KY3eQx 6krc u]քt5awhPLczEٔ\Zly2VGEv x ]Q@'N6(0PYw/ۋ>:$i:k\$ݒ /9scY%|t?! }Zn)P"l.,eG=&)*_ _-b\􈺺-!͋ 9<ۡQhE.UH9uWqIZz Ǘ%<1m M`6ܱFA ÐDNMׇ&KV|Hp3ZI' 'G2=О  ,#Jbr<2+~3/ ](l2cI-s9 p|eeWl*7(Xm>yHOZ#Iȟu 0a Ju+~YkJaYEGo-jVv*I*p=9^z6ԡr֑>ezjML6*¥fL: 3*ZaQhaڑ5IJJ6Jk֯fuT6K;NMȏ9DмԵOܓUۄoRM`F8-:qv@n{{g !(JwJI0hWh)Jzd 3&:bM 'D;N2e L:?¦/D~$Qooǯ }7W|(W+.wʡ̄.SL Y9,kkgpٗn=Y )DJA73};¾Mde4aAz$dAe}X<1 .ele8X~H<rlke1LEQh{ySZGϦka"5_0cLo[:ćm?1Dݞ=C佞Fl)!!+dO9aDW-!Ʊ&1DF;gv@nF`K*#&sFNi77\B&yrXX~Ly x9I{nA_ٞh3TadWgy諯ffQYܢXy:bܦј 2v%R6y-(RB>M : b#ϗ,wDmp%mƦu8wk8WW{ xRr}X ?}(Ƶ.rd#Ox<~EڔRslA*)k#hV+PE9kg(ˆ ~.8ϜeGN^ysJ%)7x'CEx+p`AU5*PrL􏒚@k&12^ < .Y+M 6 //#O6x5o,E|EYo#[L ?I4vɋb4WIsԓvi (: nK3rƬ0 vVDH*ለ^d4?*a"qv;#/DI|.2kmyqCORp'^Φ]%-ݤu!N`zՅ5~gcZ4RPRASA|ǻӣeʽXE "04c .-T1pNtA/{W]ĝv ViY "q`Q/8&>-vA lstH!ʶ Иa6!Q|*~҆wgMsOQ^T{X'U^zͣh%t8USyxT Բq8YnJja2˞:S1FFeea~mcgz<"l^Wt~vRSjLc"t\d뛟4E].5&<ٺOm(h**jaU 98\l~~A `/ѼB~l0zoＨ3$ ոtI$d׿ɋ(r"^DMgGi1}Xk[ʜ/z}oL%# 뢇\=M˶e=yRѳK'n9R#wkH@0u.P+k/|3zX{qX>{ˑ؆ҵK]M)hXmϲ^ف*c{?܍)р߃%s#-6#cwHyXa@6UU6JQ}u_,ӕSI#z&wNisdL8 iYXUp{,X_pp{Ws$-^:OIxljSɳwr58O@R\VX(2{3HGKH#l!5 x+}c@/63޷lh|%vtNR.U`r`_ XRJh%5+/umyQ& 5+ :}8'N+4eڳZ((j 3LSO'u3M"3G"()d _o8@,%2C0MSvё,ԯ|y* ĭԯ݁Pzl*5 j,e0#іx̮?әԍX.Dw!^)5wX37Gfi&&%~Y[v~{m)W}>?^\ړX-UXE{"V% msYyџ},9A8``u8PSrӳzӷz[Ύ`2&k% ̖G^ԙ588h2u3.ێ)RJ\];T4KK`r~P:crXӈ(CĹ78';̹ۺyS(c? 7QЈ;c^(;(*^>Xxv&Ce)`.qgȷ d9,(55ߊNjXJ?BslT =lc{%sB `.<Ũ&z\{-5S<P w]&Ch6BA^H/.q q94 1u̮V-^d_M ꑄZoU;&͒buo[IIeOeȊ ٻVS?!}Eӹ%G&VZJFR :ėz&K쓖΁RM)P4ƶqn^'2HR[tH:uՎۚL;hLzᧁ8l<[u!Xfp,}$ޭ2{H.f.'򬟼3qghh wK,(#-YDy|;gCwuؑ7QA2?YdP RW\XY2F'ٿs 1.i!$%@|YgkƧ_59.Wi"Pd>n:5lAʏ &Z~ 9e̲>>=!(es]~!^G+Is\Ia Bo[穹G(4m2G]90FUaU)ݖ`(2/Ou1}؝@+vr"ZgۏGIN$yuCqP%&]и`T6Y\Y"jRoL^+;F;~SԮGbp"27ȡA`^F n Y  X$lw]Imq?6PfL-洙z1<^~v^I`.JKJG@/ f6칑/Z`Qٵ#iź`L<,3krci7FxSw-Kzqlb}5M`ψh5mX 69z-4(:v  l$e3׊^1 *#`jg;1 V,M%IPWLPPr+ԝK㐜[h[~c^ҢaDQxf_5<=i7mшG"&hQj0JP0P&`kʙ͌۵Yʲ+t6ב@y AZֵ!(Z!sjGC D"8ȥܲ8V1a#YS/$WH_FzJ)=$@/֎o`_a>J(r^wΡ.7}@;I8UqY< ն9id3M1?PVE":XsRIL Z[E2̃'Ko35"0>g7)ʙ,ͳء^SwOBR =M!y:Ns/L&Xpw@]^STnNDHϧL`w ~v!棍)ѩhX={QZ/x,BE9czsm'$vrŠxf] O42,yCD/>3TY]ڕ@E#ﵥɎk/5m1/P1@ÖR$蘙!&fod)h&imZ)|TJ107$jFf'SG] mFqI ǁV@- ß7KOuYxdR~  .KJYjwE\FN&2HzDN}!qIb,}Xls82kQ*K$޿g8rVZ(|tZj}WFRLr*3!K@OLw`Q8"fj4I]_aLpE?)Zn,C0!S ja}Ƙ2MWsmy!3b}ZQbtI\mޥBˈ?\N&(q=$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ B܁聆 sS|11np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*l߯ {Td.n*!*MO%GRykU@F.](/] ` ;lmWP㼘ZSX9DivA+=Zk -i!,H81K R`V&-U+Bd]..wQ᠏CSϕ~1*0RUmHţz,<ׇR[m#Oj]uT3^M9?uPa2S BśUH2JP{wf۟U]@NO0̦x,F)ܧRT=o&2x$`/T]'v_&dgwJVϓz@xX!t_P!3:H)M߲KCV-ߤP̍]CO-7~Ni3p`dM4֊TG >@'Kpql?XZG"mqrhkU~I5ӛCr,DX0a%PGԄ@kUN~Cq: mZ*Rl hRp_Mun 9g#i` X~RUZM)s}ASc4aR{؟PHف&bV\\w:>QEv|=(u $Y `1RiDI}iS8یohjp5 C4KBJhE'w]o] !S~g=-dfv0gѮq6)T /V'J~q4JpȻ V'WB ۈRԾ☖2U}?ir֝, ''<?ʟۑKQ}W#i~5w>d&f ەȷytYk;#!$lh>+yhLOO@+ä%ٜIۺ3iÇympӰ0`;\_'uܽ6|K%q†ip ETb}n S POL oU(gq^r1tcd;m+93){[W󸣇7|A7Z)쥍[p=tM^ks Y"äULe\`sC$6ft|J{?A5/nl$ڛ~t|9?Oe˄R~/ }A>+{s}"<]Mo:bK棽?V;IQY& (Ry\}Q\,va|+H@.0@31Ɛ4X6ۜZd&ɏ\ V Ϋl? {?&lsiYyɁRv@ƽ~,'͸PcxP<-XnVv=3J;2r q 59w󯊛U ?FA-l(W-퐂dƧ3A{Rm ^gb0?-D]~걺;:>*{ &xfBoӇ\a_ӥ6VQeVNaoTfY *Md eTu4}Ɨ~MBSevf gGбMYZy7g`쉘iŮ|/|.lMKpμo*a #LUgM|ST '^ IAմW1Eoơ7^D6rܲ"8ů s/^]IF]FwTUx` it#0cL#b.o"O1,S_fN@N% ̇jq~o]sv-\tc} kW6Wx_d< d-"zQ"Zv2B~œ茡ޙd6kbH}NwsdXa!2 xIqS{ *Z&r 7lI0sS|11np#_(˅ѕ~*'uMدՐ%S61nwm J@0O15^QK=Kйk'nNEtR>al%yP\ jӫ[!F8[* :sXw>N?nomv/{k`0sSʼd%@]:Ă"G=EBo>77X3mt {6H.Ɖ!?I3 4mZ ݓE{:"/%$y:*`Rhl˴p`N&$aH].:E(np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t_'P;{8l&fJȜ6И}%#5ͦkC 5%2D?(.mTuJHف|/̰ z<:7KtI7xUv ?:K"2թ5L`NS[-&7@ܭ\o,:ʗZ rΛjN{n9}T) :x,d P;>6+⟎XgLC@W[ %:vZuHIk\-OP+' 'z-gJ'Z&}3H3:ud HvNTo?R`J[{^_C ޠ@,/e!zE**lnCkt1_gƭ>zcr`u][+fas+fM5\^j&lH.à\AGvs+T8۬7h߫4'By]tLЍ_V<~ {ŁʷGYanup9KY$.SCK :C솽 [#PJfx4'[w@-Ckyj-٥ @:yWL<)"ޏ ͊lwO)%5h @dMo%TPgdiI*wdxV c`S@+~YQ } ]ƶh0W qe/%KHٰS+WDx+m?SF?[l/_7 X%tnram4yGLM!^2pԵ‰R TgW*bd6-v 145T@$Rڶ_UsW6grhF&᱗"X̻ :яF^ Pdh#>7l=*/ti&TR~ҮWQTE,NJS$>!Y"1ppC:ycɼỳ~GFɑztprmzJ)9rAXDI8?J4,T=r2+%U͔zxacu5SǷT *'[_&#ˠzwH``)UonƐ{Ip暒օ&䊻7.Q[/ (fb~ >S4)x& xTf8 ux1A } ;#sY5a)4]-B P(u_->g'kHّ﶐JvusHu}!O&P`=&T0TԬP ~1 \DU!UpMtM@OR{RcSg2H&@[1d55G)°o3ƲCyUl 6ҵ[}qT&ub<؛YEdoXyO;%ߒGe)h` {(*;Gȱ>@vxŃkl8Cqs`+ʜ`2W b,mV"sX\>(fuα&# ?}w!nz>SbvY[ڭR+tѕ^2*ؗ Ғ?, h%)3Q^);6 T@TxD5Ncir|dNBvQYq?SQ\(j(~aTyrh*VCrov}" U ؋)d0/U QKm+ai(󦻼f~X9уk5[2F;E )2l9Idi*8{G/.J硽B,%dnȐbkO /;6LrdI\2(I;PoR+ڂφv]$qK 7HIUຠ1uIc{X拳e{Ox^Sk]ѢRL޼WIu)6 ZsbGPh47m#g/&p[aQ%54͆y̤`z.جQa(\jvJD2e3pvzd XV3@0f;by Hx;оhl'gL; ނv(Gǚ:F]txm[k`oO%Vngĉh;Hse"ӟ/%4怅?.x4?!n[Kyw4 ;~eWj!y;*~ںZzH4CyNPާjD> }O:=9 T9 (RrO|kʘ-4nX( 50w9LyyX,B,j]3b}O7)YØv#X7v .IớCl!8cXXٸ +̈Vt9 &FH9O_Ӟ=h2$J> @._kℌϘnV o=28 O-=ME2$U7tZi*ye@zN\' ,9{/Di|F@5ݜU۫-gzz d%)J6^?T K%Z<]p4}8'Dcm=[LkW ]wKr+[Tӳ(DZnFa}fDc+{l!V ^•Ǧ j7 Dtn<9AO|ޟ$+ a,BC%̔@:I?0]ₚ5iAiz \&g黲Dmѕ@;mc5!l[u/ \vѬn2)z&=()&Iݻ`"Ne"Q7s>鸝 *u!R"YVL1߯YڿMx ) M2>I J*=.|-^Γ%ע_JC[DH4l& OF֖bf EN#¡"J/T!]QJ5|*{<՝ ) G@_0Gjǜ%LɘC$&!M)k-mU0[sO jRh_ ghaK+0`4X*G\w ĵ $AgcgYymZ%J3-W2ŦгF%F 9T+l86Tr)*\ضy0Ic^&gfDDVgB?.owOxNRU`tvV3={֡\joݺн:HCЪ7Cz\ʥ2-V~]v۬uFXbޚV }20ַrry Xq] FlZm;g ? ߸X\!M:IKP%bVȑ0%,})VG ERΦ282btiG~E7}R6|EbY=>*E$sVs"O|g -Rم"膻Vf_[L:ߞGسVU~=۠Y{@-Phɇ w/4[c[M0){q@}K'LXQ$,0:RzSA}D#~m2_tZ><"\tr0"3rY N_ WAIÑ*I5FL⪽O!""z9BOµĞwh!m&mi#!WFCOnf'*::fV%hBtzjВ~29˶ "9#-sIlQ=_e G6)u[{#w83H Gxs \+^`rV)t9,lNh^t5'ndgd1/N^3h/tl%0YVz9#2]`dl*NwؾM6V; xRJZvW/~)(]N}D0R$}bӝR [RoaCiQ"Ԍrq =>pFNNO |S;ho=1K0[6u3 V!IOC\mGLHյ3ỨŹ`#&F;ypwJ`J A.a`jǂ>s |mߛphƈ +]ޛvk;*--죌,Թjg IlXn[i'_{W ; ;_`*0)i$Vƍ 7k4BҦ{$>${1u|D Fs #I-? @}P[띣U#{9q'[5gZfO-F}̳P2O a;::ɴwGVLRKݘX 7ؗ{4*L$fL`>1ۗXT_šORT NލiW>=BhV6D1h V:@GжIlm 4j`"K?0_͢}J4 G΄FоMOdj%]ӭOD.vC*}^:hxlx\-c0RDRg6},g@]*a6,yf FTؚŽΦAW˖ŕ`wuz廩4* 3 [,& 5X>udݻ!mӮz5)#S3ℕTT91s\i( L!aoo}"S](a 5tVտ!*dnw8a6qʀ)0St==(-s&#:19kKh=D^l"S ߑ{.;(>eKVkFb5\NMH8/R"oYA2M`y_!c/KV#/vB^7E}@Ȕ؆z;2X<dhFdV`eÔPؤu\ r6D`pN^w( Tn׋ʈ?_1O=〺# ?}w!nz>SbvY[ڭR+t[ BS=(JDVK`4P*  /~ *c7r?%8pu^7eBOȻMp3vǚs;oCq鱴8҅.HS (F|0.Ve%S61opMG ё`α'\YfRXvY[ڭR+t[ 0oʙ'`rֺ>C<20g0b]|.S;2/3mVXYDA>16_auӔx n^jCKM䦡dO$#oK7⠅o9l&9yzq̭y,8W7ܰHv`{IԱdB]WExjvzYOF²FKW٫nyU˰qV).c~yofs\0͝hEPH-1K0pm`{ ,+K";zs`ܮcRmʈ?_1O=〺# ?}w!nz>SbvY[ڭR+ta՟sS|11np#_(˅ѕ~*'u>9sZDADL+z!(6f+ Bا)Lh*F5',9F!7/¤xky0ƙp#Gݥnͺf`q\}8ez5MZm=iߪ{d?!"ˀ.H{jӕ6J TeqVMLk%K_z Q JsAxȓL}YAf4N5V5Oa+>;Mi:% ߂Q U)jZR3͑[@JN[b!_U R/s:2$uh]oX[hdwS6@;;Fyp.[z vWMioKlBˈ?\N&(q=$p#_(˅ѕ~*'uMدՐ%S61"2J .{`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YR˥~sS|11np#_(˅ѕ~*'uMA/t'@MY O9ѹT,zb`م6L ,'5$6"F%īDZ0m3[j<&~ľj h&8BxIjD. V6܌2CuRǕQtuݳilzSj:!?L~ 'x}igGlńT߀Y9ap+v,h l@Jقj*7ae8q%|ƩьtM7SoI&oӰ9g<%8tΦ;= xE)5ζav *,-*U}t\7l3xU-66fiü'X3( O^)W%(1]X'ܧlܺ^{c@!OgMnIB$j5=?YU |#Q<2u=s'&# ?}w!nz>SbvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F#sS<l H 9f5rN  Nh2n.qQ~[/mBx97 `cmO1 ) p7g6g M|d@nȷҙ+ ogtO3WLqR?8৮$Nf7x⹗оAD艡h~h;@ eހ6Ni=I2lX jgϐ{ 25CPnj[6-*lxWg ⫗,Ɖg|3(u5= -cO 4A;AUT٥`O^`gA +. /\"L+0=窊fޑUiσ_nIy(z sZAFhNudyBrgpuJ\&n;Dqj bvjw*41gWPE>V`-t*h i|hDv"KIZC TR }QuMQ9͐l;/ک Ag c&ݿrχ8cp-3ʿFr<PKSQ2G02RȘf/ 1cC)OO G+ Z'9pAP5 YwOY'I?v]ݎjj6 `GŚHe(fuα&# ?}w!nz>SbvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Vdyڟ2sS%eb_PT$Gư r+60q$$,5 BVgBu`9I20I:.U؃cS.҄MFyŷ}AxVbg/b\aЃRrŠPԽ|^7O'z& fTtYLEMhky+U&'FR۪^w˻t\lʇq2D _GP BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\Y?3saٚ~ˎ)<M 3߲9C93o 7³'CUGGsӄ-4oF27D!FyհP$bf=۩5Oճ YgI}\qWQ.04em3*/-6<zJ^zI&Y%1EF9I@U8ЯȡTŔyY25~jS( @l '*XKyХT5Y+&(Y. %MȂ 3եuVoK1}NGYHr)j0ZtB?s4u%E@5MjY7 Xcgf`EnTyǕf}įj¹y=[ Y CEayViXM%!Pd# ̬&' *Jz.)i;걎2r̹aFťpȓWwؑi &.2!{vɌ1Ʌ*]&Xo>y*f*Zgm 4tWTQνINkElc I3+(l1{Sw msYͷ|7 +TDL{EOvRu$+ۯ| 2,2u^1x%蕖jO!O^+5o\ 4:3Jv V6״_h.cZF zG]p+xs1)*M|Mp&boXxlTn!]:`l6mnۼ݃lq;]z"4zts$pcS> ^cн6)d{fg"v"Uu1c6!fw"blLuѽM4EJtŚu7MCoM!3E*y\\uQy=$C+Ȏ _UTEӃ)j ѝ Xs*0]Y2b&z^G&4 a%Q=zuh L_ ￶y?C0})iLn.+&<A#L$:E|]B=gD7-`rFTu,0PT"_p;27 *Z&r 9$p#_(˅ѕ~*'uMدՐ%R:A[5dI2zC2 m;6ka͡_ }(IQ6.S'$ٵg’Z~z]aͼĀ(Q>E鸝c=PN+щ_0E􀌶#h,ȋMːL GqLK V}`1!NIBI(U2kT_S,H@Ң/Wl Ӹ!DuFKx47~]Fc?agH20= l`^j^#^p_}FaA9R)#d L 1 YTuMHQŦ'v)oZ7? m╹yI/{+}+)Hu|'e ?+K%SXՓ&D z7GZ:d h7`u.e=BsݮG׃?P:Q){9ƤC+0MP6r0nc_e\MG&f5zgI_\fωzx =ghO\;AeRϑ?ԸTgĚВW*Ym(tUE0>tc~rA 55z!躇RiWW6QG@{SY̒q) kH| D {ţͷzT v[{(-}vKu} _5lI'9Ufe}, ?F`! fsxj6ɠZ=sgHQKҗB`ü8Q6- vm{g2*ۯz҇%-QsPhY:(S,@W%[ ƂӮC cgW2o}ʦN^:I -DrL8Nb9s/48$8u_fMnY8)U0\490Hb]K÷]xp xT[av 6`OL2 LIz ĝ!рP}:_uC G$@d@h;DI ЎfV/ ,;@>GOUMR"[r!_@vxo3MZî>Юmل6Mn0d4tM)-ǨM$V"sb7I4YطO|4ə'pgT͒0^&ddC*ޛcn,Zztgk!1Pc-m]Sxfxl9R>OU*PL BkοFlJ涳iNx>a=NzwIRH|D:d-s8`ٚ:njwى*.#́TUǏ?{*FOEZs_Z;%e7n.iˊI3ݘ28;BO]3&J xYh6Rbh>Hg帱vQEfCRk^D燋lm;ocN7_D\K![q3>¼/k0{hFѲKz߁繸uٱ/-W"Z*@5jJ .nV+.ʃ HpC,+6~?_<5gn{/ϟ8F\(Q`gưLAjC7@.T|"ʌhzrbf"wsU8H#cpsH-HK6N:24Ն/V"yn/z}7X6f;ݩFгsH)?M3iI:ʡQbA +5Y-2Gр<'2յ_3XOO̔Oi|=dֶ="?Z% Cx=iL&EbԂ[}q~1ٯs"EG{. Y\g2q= >>VVѬ-^;v?p+kLɹ" .ùQ+_eay.{aX"8  g%lm<(} >hfr.BeO"K& ϨU1yך6暦Z V q?&D![ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXvY[.jf^$iݝ%xY (F|0.Ve%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY -Q%8\s"-7= we(\=Y=ѺϺej}kT;m 0bSoBN*JXb׏ "wޮ*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ё`α'\YfRXu*i/afQfͧ.E([<'Zj+V[B7A 4Wzi7?8T4LL=!3||K*q:y9חBMB,nNs>BۿWnFTu,0PT"_p;27 *Z&r 9$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڥ^ԬM!i]2` 4M )CbD%jhk_$D)e g­ :.)z7fYQ")!\ jf4jl051yY扡&w-T1aH2q"<3S b(](&:uj'*_1s\6h)뚱}!M脶+쳌I{QٸipDps~,k E٣ DȻJN魌,0A+Էf<uS<R`eaR 8'e*/J{WLEH.]bc|֯BsM0~#578\DtJܑL;{^qP>Yx4o vvcЅ.fH7sD/- Qe &D'(h@9^fp#N˜ohja 12 LJ ɯ㤩U&/?; ۿ 2a`|KDeȭF Z MP} /A|ҵ/X,9F.{3)rv?TJii1^4TdW`;qzW!ٸk=J?M&Ĝ 眷(I繊uO<ȷ۝1 ǰ);c3)m;ewFK}bb ?w8603{e4U;:BʺCYp+}':^@{ yHPx֞M 5@0]GM: _Ib2eZ4 P1ܸMtzw-Ւۭՠ3> _ 7zԟ$#&kCoQӨ*Ftf5딺+"w8Bvf: . IX-(ʔR&fO$ ´T.HTzfC=lܾc^o=N(.U!xb@{#m$51 ~%}r%ZQh~#QǴrc`b2YP`픒N/C7`e_&h|ǰb1\ G|x&q)gT` ,: z9=^jv{h}GdFn:=L0{No"z<#Ț4 tn<:_"ZN\%$:t^_=.^Uqגa;͜չ~I &7AٻҬŌ%O2Ηqn}:g9HxE"dIԵ['7>3ba,BYGܓ ٫4=ֶR)() oeɸ׎޲l#P¡muU9kS{ ח, e.9 C+!+9e&a瓯S76Ca 7pTSDMv8 tm{:O@;(hĄ JG:38D0d6K#sݹ `#tI1Aۏ,STӌYO.b9hG∠s)j5lh8[HX?D=Fr[`?`'Y +k*Ϳ)!5oV)K%f`F: z/j9.f<9' 7'"v+SUtSɺbT},TwBW:fjzS~6'9>e#td+#ER3q6~tZ:p/%[b\aZs/[Hkɜ%ɀ챒STiɥr)##,WUaE^&NKrb}#x>05G1 uI7f-އـ7N3 ~e`$jo Jj7XEExp[?"O5h"5 +;hKضi8oiFTvQsW11L߬6(挷Qh\D|#d%=Գu6Q'l,Y|W#oȻytm4ʎWeC'3,w uw E.XCp *^+9_5m E~y&h~ԜS7l,6{'L65 QX`W1:Q !{^0w( Pm}˰IOC;Z]dD?۠'#iWz1vVeڑxiͲp=D2ۘCcmuN| ؇ی2V0SՃh$]A3dD_w,IОq?E[e_4J+[[|I~+"qs^YP:̙Ѳ~)X"ߛ81SQ#$yp%JA,w9! }v?/#d(+.Te=p7 KG*#d:NwIȮM\5փaeEHAn'gD|)NdX4޴>!nzVxtkLozREx8B1^r ĬW qF;k!`-t.|%A6i9+nӤXbsÚL=65CDg| ĹR :PKZ{>OH* B0k4)dV *rTZ魲kC=oKxv83 f]rQlȷhj.۳](r-)g$1\dugR8-GF;< jXՅ$@xݵ4$*=*-t^I~&KZKYv={Sǰ^v4n&UsG0y _1 3o2wjy6_pɩH^=R{V*TŬ!⇑r^)WҍBeW(K,3s㉛tj,̢vwuȼzGy]eF "F+iF1 z~u5j˕FQt=/1uw=N\t7z<%\gT4Zmw3nwY+'L\N4r+k޵֝QN L^dxRR|f.;6|bLf:"P\'|  Gw Zx$A@(óR[iwxҮޥd Je|ZOtL`rGdK4iRȀ}m,K )Sln6ry~PC-9E j,SVlr2f$7b%^wԨKs$N ?A>%KKmqlHWFǢ7 RqE_]&Y+pWqN?j:G5e_r%?HC#nE?XHoZ4WPਢm(=oַ\·p?"Ӹ&#JJ(>,CC3vcOUα@=w!go,{7`j:( GxgW͐f@p]v:ٍWrՇ>O_QBՎMheAbfG$66T":dȷ ~3++e/[؈Uj;p|.gvDrx6gouF;+b,%7fw<'rXI, ;:-{"URs')+3@݁\?%M‚lQNQM%(3}A2zweJ>E/ip9Nֆ4[+֘kz*b,4&Ό~sIUnnv栶%9?ۆ[NЧYٸz&yo{FUXqXllѢ·ŵڭBA|JQK:_>-k(&{7eD`o'M9Yޝ mr@D 9YA:Sp-AHqCzmHd0o*THWʦMA49gnkϸa1bJf 0Ko<W*]CK32$-YYbnCv0T"bCL[{8fv`0JNf5홬JvMpq?y */rs^$R+k̉y*AM5$I;kr%:B]MZJSHw{ - `d6 ֡1ul+VpG ia)}:vS R-v彞>%NhrL~_0{nyʰm*Խ傇2I&w暵ND+sL ̏ۖR`'AC'\)}x9|f@D⾉Ӓ.2q/Q<Jc(R79j3`3x Oh0C$tg y(o= ߼>%vZ($z8p8{fT@Qc>|i݂{ gԯ<n eC"G/1ņG$nLv۔oDbh NAoqsO3 b;3="' ZjV74~7&E|X,m}QS`aXHqCc a9~ !wAr|:M@oFo Y1[ ns2+wΰax)fj6I@GsxLQGNZK D|1Z_hY;ZZv` Shdڎuj[ӣı˜l).٥UDjmb},X?)F _ %j/4ȽqkI^ys'_']P9ciHV Md\榇+]v11S /FdKcO*Lc]?sF=45eKtAEЦ %`Xs`:)0|NA\zH*?̼a mhc֔$Ɵe^~:V0.ڥټ&P;x2C]Ġ: ؾSz~ ,a5+R%NA\ UTqo`Sۘm՘7 @F+4+6+\+ .&ۋ uߗNwqoǻ]LX̥l~'v%1uSpm\NAuۦU`!jv`lN55#; x~}g> &F 7!1~?ZNu;jv,A4*_/68nyU㱲]T1p m}/ 5x )+Tk83JiscbKݻZ"5MPnaTGtdȐ6ݯ3<29o*>[kQK6|KZWK#DirJϛK5 =4 RɭtH!Xq@4:h\Jy&58))ÀF\?3Z8_fILulLV08e4@iBity凲INMv1/Q1~eV Qy(S/"*f$[+ XQS׎D+JS:VTZ2lK/v(A+_OfV6Qבwب#|:gSe{5g G56V@xK泇Cn0-E (WVHVGEm0K#.5 S6ִ Eʾ؏0T+J*^2?Wv0rg=hr  @ǃ0^٠;7EW{:wԛDˠZ;%]1G%z${+\T͢>wi-\2O:]yF t9Cb; w7u rnCu5-*9ljv" M{=Na/j) $E P+N4x y7r"jT X<* *çݘsY@vP 8cInFңP= )aEl,lUgxL )XT\#e`벿9ڔuNRiHgp~|1x1MށV oڤyRH;&w.qϥ{!MkMTڼï)c<~I?{e_OFMWSZu/jr&ko<a %Wv?&>1 B)qDګEԽc !; о/! ͮrO(ykjXN04c2^vZ$LwIZO9_z].>ʁTKI4AV-և1(` UD۪`]fq,*=ְϟH_<3?2G}$'u9qV^Ⱘ) Q eOjz^*[jN; .^H basZ.^!`O܍B[Cl$G%4_@SУ}ro;?اpuElzWy3`^07e ~'=L-g: Zj=Cx^V p`ӽI.utMI6k0m1S~I{6;áe) G e=jOB:hu*Y`Va<J'7ZⓑO#o֩Ί{VJN]6@kIݝ~isP8Ct@Ni @߅Rwdd+>m±"V9o NsD[:|jsO- ?r%@cvU1|⒏2ϴyzũQK:V v*Eڌ|kNȅ䕓.cegl$g.A_ZU7ţ =oPx@@wYv7n`8<Kp{|bX5c} j'hw#-l_8Y,]Qn)#qEc۪} R%:&gֻdn9p\/OZFQ^QIj&+ @!FGD%HX0;LZao.̪HCQi|xsN` 4H2ULɗXZb$Mh#6#S܆;644CgЕkR ^(Z8)x۝h˜tRVӀMkfO[%3d/?~z_]Eh=ebܰv,8 m`|{ hK@r o/=& PbҘ'$d}#tutXc%I`) {U:ݬж|)*\DT.ɪy$}5@\RR51镬"1umދ&Q8 ֦I^OTZ"Ӊ;OwidLA=a 深;J>c &|Pi(~Wm]=ݥP$%HZkWBs*G0c_2 *|M=#^ECN[t}#; k^3Z 2PTĎGa?@98ӋFs9ؓ7ya'VoG*Zh웘câE'qک&8vV%ަ>ؒVMat婢[p*\㼁3Bc\W3eҺFsI)DƣPi4Urd2@@oVk]/3]O'|{s $EX?z!(n {MӜSo!HP@rt۶nJS쏻KZ@ Fs7\ģqЋcLQ)-)!>fx7XirM5ӻ0|h1|&cyl:N6)ةt%8yېxvro+2bU beR(gDup!҅i$J s n̋8CvZ\3FT87ltlŘw{D)KeU}e+4YsWZ}.D{E,smgӅfJ_"|MPI0?O=b$x&9L52Mh1{OLz 9+20bn \} `g#TnhfO%A/߼Gxd߅Af8~aNgTh!x{{.Q5*6vYQ4%wmmK>6 J hY }N1vIz}!a4M9NU8/HFq]Hk?fE*^ψrPU%KCY~s.;"h)!6)`6e"G \!Fxv;'ҀPP)vDgmm cқ^HLaR2m.%eL@7kNN Q΅Ietek3Qq{U5T>DɺKf9@6ޓKKkVsҭZ @!={\6v}eBLobR"" HbIHeм1NE+.@ E4< ZLPuppD,2v}#$fjY=lɷ_;4ӄrbsR|սŭPI\]o<\^;}Ǟ??lʃhV:?l|D^S F:4$uLsO䓋噮Κ{W^r(P4V賻4 h,&8*SUPQ5A '#I3)<)ڱ [:g%A`;Zf X^ C/76 xW:CAw>/ Rrgn*k>BIcbV% VXPrk%$A]@z=mr8r%{X smAШoCn]&N&>yzC]\i`t^q  "3mb8i[.u^M,YcSFFRy[]׬8L{Zta§|wv 8^XE|nCPDC{kTPo=.&^-!-N'ZPьF%\ށK5!owF/3 Ԣ҈S Xp.JƵ'iRk0P4aRHYQE *GãXvI#&"ѻ?.?>7&W0U.K,(? |z\NZ]e%^Ij! q@Bn<`t^;d$~I%-#0(-<ޘNRl[L3rR%Cپ[i=ÁEm._Ǜxr gɆgZ+P Q,M/` L>NZ& FXÊ n?홫òYi4wkyH z! ed]'LͼOl㱽 m{Uoǻ _#H?lHM<5W{~ݑ:lK,_G2+BwEcO^7/SP ҇0BGZ2hݕEhDG~ho'^.!G-Z!?!Ca{3܌E+& $gFtLhSϵ5T SPjkߗ@K=%J[ohs f0O֎u+ .13!Ca8=B4<*ӒrANKY$0IVxQp ?r1b#hҫH* grX8re_19bZ&3b8X{-{Cp:aoa 6Z u=lT'݌a^$ʥh[8 P2 wQ.$PpѱE$`IbѺnϘPD]Z΀Au'Hl(gFFܻ_uޒ3KK9BY]h] 8*>Ƽ9_(oos G{MŁ]+_Rdch>iKm*O}Piσv =8(8[)Gmk7{$yOt͟Zyȍa].GQRNuw=, xw< 4Av[ c~*1sm{-H}`\w)I6zms|DHg?#9<ǻVt$;iƋ+e]]ϡ̱^ōu̩`>*V7i ]P6ײׅV ;ы_]^. <Yx]R_v9@f0R9, lg(U nTEҞcG̥|.LTĈ> i lPONG$};A'>:E#SԬC\QhӶav5[uEf}Qwkp :{)9}\ D>I,Eg^e@?N\BUҚ疩q}|Pc73.^XWw[W *Jw`m RY[:ø,7K F&~PFPmqҽ3TC kgސRQ?Ld@SOzL;\hGCg ak:cFGg+ a}zb胝a#Żx1wWq2Aۘ0U K. I Ї{35Bܽl#QF"zXcQk0IY7 ~GHChD!u#r(QkDi>JYaDf@*B:ϼZZg# pr{9 B0MJouّNyQ-~&xIbi@gl\҄h1j-L1 #=շ0& & j;xɱ0 ge#2G-}t ].$zo2Oe+N{w,*43:6E9\1$ĜT9{`+ U!I3E/b,ΎXr 2Hi ٌj~7y@ƀ|;I)Qr([7#%ڶ4fpi ]m`I-">"ԭvXgp#iW.MP`\He)!amļ*:z\ }Br/_ϐ$Kgv~BP@ګW!`P]jT(,=mDqdtK3 r%YDӀלKچ0iQaOpU#%xV¦ggoHS𫘂w!Q6 ?BRoSlԔu<+oaw6{CqUJGp~Al !s/iB(%}+CܾvIrb,l=r8e؁P1{XiuR kH6p+[!y\UUL骸_LL9 sܳ l V jӋ` d (T'mZx^ca> 1B!Mpd8XVɞN J&v&D 5GVvbBb4n-}1i8s\GئW<.q=)CQqI+}TR,BGc5 ZkB7 >nyQyn~O:PmPocxi>8 ,ҷPNCXҸ?W$jP{B 7NQ٨xbfvWΎf—rn!'T'ƣEY,g&,}<?^[ojgWKҼ!xI{\_ ͩ$ʈa DV"7,9įl5ӞDE[c~ u/q~FS\/%PfS)VZOd7'YѪshkm5 n)['e^:z^Z]~>b«w!ǔ&/+{GAV{fbsrK\)+O"Zǫ 5N]^vu0[d&[4`?DPI؞@f:`1M9:O ;E KY\nĠY>TJ Ar $Hb (Kt#gԉGS2)=Dgvkc~(>ϒ1\x4%hx*.O[̗n"Rdca#Jun +l@$Y7!0K嗇cGm (a6 1;40n)EH=N%ʳD&BG,T8d_[}쵺 5xˆû9sn__{"MgۃP/b塗wKYl|L\TN} Ba/tK{pOen*tgE՛v Sp/8$ȣEMns)|UcI_-]YcLWN]kJm$IgyAݱˈ-+@T; d& ܊ؤ@<&V ;4bؚk^EU hN="㗰67)޷.Fԉ€R${ڻA>EÔJ4ϕ4xpw^$$EG[D#yj1})28@W:[VD^;- vS[@nߡ/{ sXZL>p 43E< &2 \dΙ392"?3OʑPV8hKXk˩{N$/t}i9 WR7."0/1Hp!/7 XɃu뽚< b[fLgi aKX?[ʭmUݖC)Ŀ ?jڤ<F30O '^+zbBX ";gvc:YtdTK 6a@Ţ:?b^#qCR`ko0W&,m F}:KٍXi0΂ #“L(baTHؘΌ??ƻv0J \ }8+B1"O"_N' 6pݑK5-Z[;VjD/#81qѼP9}bb\Ӿ.#v$>Xajp$;'KJ%54`+*"iәqi}(KdNUQ WXQO?f$y@-|0kLҚKèŧ R<81Уd4aJ Hį -jz4qqu-\c;2c^<@y0ߢbhUM=QB-Z>y, >D i.Ո#owig#[,_;Lr8eB0Iz!qX3tF'+VG{6-2nn#B~8#* hfOOZJCCp̒8>j9,tҬlS4s;JtGv\g_-eXXtU&)tvgºﵳEk]Eʝ1KPϵj_}v!ׄJ _qW5IEhէx0Zb5`]cx25gw2E7AN6!MY{vzٗ.*pͲ2 w >)FkN2/ſ-@5/8Q^qeR5dB`Y #~%0y)4~5pgvxihgv`]-4n# vm;LDkJ73[6rYĢmTr5Jf>wb T)J '{"6/u寏`Bw% }[1PDlqFx('5sVޑ~C,Mn9rx@Emfee(8\A8HɓLm%g6j̹J#̕Sڌn|{}в9~i#u^@ )KC#%p+:&=~uxi:"KU_&t6~%qCJ-^d6Z#8vZӚ7l.O@6J 8'Dt+0&s._ڔrߓ:f7JmXؖ g-/E)W +l;Ū+'\ v.J"*Z 7K/ #%Yk 2MJ˵}>iRtC.!!ԕ*_]W`My+PYŒ} *mOiKܫe5B8Uw ]_,I.UB41fP;8: 4 % ~kd|ׇS f.jQMV t˧lWY5}N~T}E5)ȟhKoy 6K n 8rмE*`8Ttc 5 ZT"ɡl0}Hhq*^xhIY̟>rgO ){r<8$Kl._<1)D)d0F+[ˮArz.TZ{kQ!Fҽ8&3zJ؂D ~h [H)A_\ʈ@MdÞ2@ b*Fօo#f.VZ0LD#/ BXz^4 dsPNPir13A9St[줝GPR٧8C-IAEyb$]}Ay&GR٥rPl!'`<F3ժQq5glBAHl)2 tݖd)3dI᠏-W)Xj Ba5IESΊ WpȪ"X'iAqN;Wb}.߯ pʃ# [b?ȇ8V)l̒m%FIUQ^ƜJ7=ST4IoG;nVuhѽPG.">:s{#ЦIHfdG7O#{k!,ߥ*j2]M#]=Ly6V {SmX]ƽM67i/"29V'"4)byy~XQ ae(w(Sޟ;^W~ pr04D`Li  B?MXhRi+w0 d`(hU[8s&ȜT;o9WSL:6䠍`K>ހIBcA=VLD4&2Hm V1m 20&\\N`FDԚP@*!&fޚW0yl/O|pAeX|2_b*dG< =Tl[ '(M_W_h3--6HIc.ap~1$y p]#1F~6H6܍:o؇Dk,$,}{ 6}qN-YA;e&])&-Y2/;^JT{~\Q+ZT<"lm+6OI#Qj+Fs 8S-˴i Plf` UٶrD++ 4]~Hߔp" RӦwh\ke֝j`,VGþ&vpץ"ML,GrxԖv9KѦW z%Nr\08)XoqI)sc%#^(USͫ3y/i!*Q mL܄5>B%-$F5_L [9 Be? /SaP\<)kScKrB רnLejJP Ǽ[ǨܿM"F!c,4{ãGM c IeOmn;|dSV+P;3~Y[15?;٦+l8߰/)z DD,J/d]YhpQ&׋blCVL mRF:CDwbG4#i[}(Fl!UE2pGW|r蕫߃XÍ4f[::yiN:vQ\ɔԃF<)~.|E8*H:Q.c/9JnfH"PP .TR*s0nUi|L|Lk?P=t+KIFu[P 3#Ħ v*$}f#ȸJvsX؝=x摑?+v"XJ-^nO]{ղ`ߗ:%o=DМ7!tE+XRCDYё.h![*߽4xd|*1t^u =#K!rDwY]:r4;Uvt4lzGzm'g>4s?S["=J)?\-Z#$^-w3aDHӤU'0Qw/`#0|zu5偅"+0?caK/q͟˔ȊH;>hڤF(A?m_M\b`>1T`.!Dž x ?svEX;wLР\M mIP~&|̊ %5mZ~|n&?ðtI fÛc8t[(&@1$e[ goMX*^(%`)(J!D͚w/Ow0~~m=]bw &qa4*ErJe@A@Lr g 0tTCfky22T;hٞNfYŏK`;@t`wyZ'\2SA䩤IKʾ5Xߚ IQ1Y C6BFq)aLOd6 i; U,cBNWIpybΜ l2NYt4 4Rw0'dxw d_UIX70UYg'a縤fAo„U6c ˋmYIP!LQ\8R>`s˝mse`, 3]4-p|JO-rwl/3ҊMn[QON?Mk an~OCޣ@^#ST$Nˤa]hxDBّC,h]q!U:I"ߺ 9%/!Ԫ{+)9B BS @:L/jxy*̆X*rS kq)2\7ᩓγg9 c.(;*Bb*p6 *砿=v,H\\dy@Z ؒI?x}GQB+rpIj緩C I"?!)CĚ F ʒ^/G+e7%SֵF|^b(; a$ni!&ulxljƙbD+0X|V̌H9 @W3}A^ ^ yVQfMhܸ:=ad~}< QYKb& 'Z2m9; pK)v:GC(J \'7 NȚ/|(W݉=]jzٹmП՜@ l6^fȧ6c뇣#[t;n\ \ (J qbMŬ^C7KC!hT zύ K"eV>P(o xܾ~jb][/lVsyIs|B,yuh$ 4u'D @wJۓ&L4NWaB}j4[9Ʊ5+M㏔3z&e2cYm!lnΖi[:u兺 "#FFC$P|UC9؍uɿZ!<`ےJI5KnǟY@2u}]`/tÜA>Wq 1]~s5iAKY*{Ƥ `^PRr:D7_ 2Hc?f*QVٷ]WU\ TTWmsjIé]Msuy/m#`M~1]7" R`!Ky16L YH;>̥7l1T(f$N N5+#̯mCQ.2̼fwp#]q uȮ=jr_Fn@: ~ck夯TTZ{:Rf. _dL} ۶c饙q%~wh5-/6#bb-KxҙW:"lf$w"-|{'u!e 1Op&$;ϘƳw ͝"v9gG2/]:iܻ[4fg5[@=\PrF-{T/BZӋrARi!¶4=>7ش0\A]W-eI.;C kY1![ Op̮vC ИD:O_-͹IXOm]ÁÆȿ;ho)(`g뭦V1p"W@a ?E!X ,fjD'nDwMZLΛJM:RGV5`Ȟ(޵JP)Au~hLXʳ&J2ռ8. `@'ZPyAD#\;g%m߶dL!Ԩ;ʃti<qf0'kc 0C$#3G8Rs&ecdӭk*.Xq|qTX|陋/N/a1I@* `05,M!c=aoF6=( aQSDû`W6=D&wѿ!D5}Y81M?R,gZ1o,q6 \2#"Ŏ i:^fB ջU95O`;Y qk62 MMwt]ǫ)b$}I{g { LS qWxpaCE葢 Jzv*(Ά nHZ; }d!/o>Nawirap٠T,<e☦2& .U-F fR$,{_H )#\` qthy[84>& aV+[F(|χ<0/G겦8%>/lʙɉ!)ܳȆQp*jߐ#ﻰsPk,BߥzHM:K6/ '8bWceKC? &/R(CV-%K!b؟z3][In8?칚,^~Xo_W 8.\PWX;uM~mƊ.B:x .ޢ0[Laÿua>h6.;s/;*dˬh|㲵=+ݼڌE~G.ekCrD'͹;Vk56Fd;inQtnR:KѷRX0>!~'J>ْ?w~FAZAx7w0٤xKbXWD:׶TQ f8Ed 8= y5qSS!!&Ԧ|=@)'Z17ɰxpC ȳҹ"$@_/ő3+#P]:A^lUfh]zf킧V)47Cԫx_?w+nF/qV`)`µ?hq.)8dl~})f/-)^vUxnfϞ$E,8X)`=)e'agUVR<[;@x 2KB}VW[f)tͩ/Am EJx'sř7Id])MZ0:y!4 wfXz!!ķfӯ@Go[)( ]o]?m}L$6C aޱM*Rltq9wյ򋆀Y d}@ ¥E~Sɷ #tɮ H%mԄB0Q>0Bat:6AmT>UmjTv𬇔وk %K4 f*ieڣ7$)ϵC" vs?KέdSx mR2jux$M]rR` nQ*D>OCXJS*,'.Ni$Q}$G` m>n43LJKlhtgfmQ"hQMsf'zo5d;Ƣy,_^;am"#g'\~A$=> ۆ&ntj-&'( Y7VT"$e*o! +ɾB]]$Uf.{m!p㯦̚,5" b!<;:-u~A`RR߇+Rrb&C H>bGF9_0~]"{僴<EaUfEu~]7%?,cGiOs׶yy R.J PX^Dۓ^?3B,F"4$1m]dYv[rM, 2&{]o!xp~kHIpnT#eEN.1zktv9 L2P`#yOg˚AW +)vx{sm[WM0څR'_ӫ Vzhqi*ق֦IpPaW@\Sy>R_FʮBzS/)Ǹw {ZՌK6ZӲ&UU,XQ&B1IPy]>+Oq'g18ڰG,ϼV&B'(w(TK$F K2*:i|=׿c$}TȢ<ǚ`pra3䝏\J"9X(|T9ؙ5]f~4U&2\5EwS//˞ijn_+6KRPDw^N8nHF͗Nb@?6t Y@@`:^5j=:>$\P1}RDSl}%Qx)%"4@6"ٷBGї 536i_?TyVY]>B8 wF9?Q-2wKhH1Vtxc1?f@SSJkXUt=!RL&dqoKN OD&(X334f=ڝOkڋVayUAnTDds^zG-ů;NQ(ىz^{=׀db"oA 華AkYWcMNTfhm,s(Ӎa)9mfnoC]^@0{+]?3jt f7N||g812cnU&,$n(\!}<3gp5 {< gi o4ZŸ33I"cAEhu!d''UlՇgfT Mߠ?*bȟ}jNj!mԜ@( _C\݌EHh_t$VW]Q{нKQp15s4>T};gM'faڴffKɋ5x R&Wgˇ`F"C4Fl"} l^O`Yi5Z]6E.CօI:O%s۬i%d@OSFJq >LeqI GA )Zx4 j\Apyb=?_xRSbө/+^u3bUQ3 xad5rb!"Y8at9E%/>9rZ=r)]8bJu̯ ugoY>2[zxQM6(8^L&1OKWXP{- S é9Z#Ƕ:E忘ex|*\`mbў~񫴾GYR1DPh)IFu6rmVT 0"G,4+Xs"Ǭdx4j'TBGQI7s\9.OL?.]ן c¯=âa\B9/$eS+L;;M8t-}q]VTXD*n=H}sw3-I.v{ijl_ݎ4s\@X}؇7&^G\ PaP3z!uFKT0z(Jevw4rvwp<(- íHcZ%a:t('y:,A4jD XQdsT. !g VMl|]4:Kʡa^T‘s2~Gn5+DfHxp_*rT4. yή}lX9ҕo v|&(SW棉̟ԣ(Ԗ8$Irg ]yݚvZ<0҅D=)4mq-""pA1zu~o|P"!VtwH9s? 'jM~`,V7m`˚~ )Z_#-ylo8V-2.[ w(DH󮋣.Ii<|J@0}B4rf?N6ۈy"e''cJH36v'F.,nY[rH4!ī\V- PMjXP a紩Tc\(kJwUrf0yL0G &ZnASۄVbū*HWYJGP1ʱki0}ijc5 {NK\-9D} ,2o 6!?iYJ-E{\1"_vl--`҃iYLGzLk0sS|11np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvT:k֚tɄr,jBe Yhguˌ=&2-h+{^&ۖ5#vsS+{0sA5T2Xy@dz:ST }= ;8C ,Z:BqzKSIP(Rj8qFSDYSVՋ/{\չnL(۱w/)z_b Q`S/G?) +.%u'*cmdj ('$I}36T0ލ3v ء=~"P]%T8 `K%Q5rK<2R@{sɈ0jt%۷툵1J(c7;v;2x)^HRdvJ^2Z}Qv,i:]T~7:aȊ|$m=W}AQ9XG_j=㬎>3U|HU@by|lBDw =RYj@k/TGE\eM69w3E'*(В`)hj0B@ґ4.|"i oG`iJ54?Bqҫ0ŮU{iYS9΃R(BP1+GD`(!y>T?}?$VUDՎ*)$TT!0wX+N '"&ZHS&VR&Y-䚘pcHob2,6LHvLiwnӞڃ 1 $YzK4Hbl6  @25w =T#aF`p ^lx:ۙ~B=Z06U,F̆uteD 2,<[~MVj[hx(U ouC* Y@ "|o8T-]86*zeN܍Aɣ >6%p?"nZPL~OZ([|<\/TT5Io-IߪSEGq2Ԑ\]Q@]c/W-P Z {ꍨfE_Al?j'T䪥v=/Wމj0Sgi~KN e)ˏP)5x'K%$[%#~g_,J*nSݚ}U/c;D3w/OHڧ/)γ|QIfL@ #/B4;IdدeSCp˜'Dx}ٗZ·GV С 0u{’8Aʧ]i>'iWo>ύ /n5\L\ YQS(J{rpٱh? iSWa04{~?Q~SZ2>/?wOxTʃ"a >vl,_KnS#Qmf_^ EuaL[`LĒw<RN;2_217 {(~Y Ϩ"O>[ 782EvӜS'Wkc;F].OSt'-w-{]zʧ[&@gϽb\ 'Id_KZteL>q9Tǽ{BU_u\`J7C:ލwq1NA)sҥ[X} <0 708(&QkuP$rtKXp kjZD?],)um, 5 `3mrz_<\2wrAZE`q4ŭPD9 C]dIq&u"-bnRFV*TqQ5!a%WIoM43J! Jsh{ʺb#"+JЄYDnYRlu}G9BG17l~vb#|JEGj;)tnGNZ 5-HadBf+;o=_e1>.,8w,B"fX7Yŋ?(dH@dI8­Hhwdc.\N0us*dZ/s(|KTVs^yNr&OtQnmJ){ ,qWTV$Ⱦdws^ Ħ1Bt?8_ #`7]hc] e_w)ip[~ФP=-2:~ME372vx.$Ww ,mT[Y).4݁GMDocޓٯk_$`2#V'*nXECpe6ݝo]*w\: QMWAo:IG~tAWE;n5?O6=Z%T6ĻD$~'#, /2fD\@U!= rltTt!9ҭ'j@ \L]`-$n@sG{ {.K*rX9/U8*⤀H"6Od@ HcSkUiJ t{GvGfOi+kAo! V5Pu(- ly%OM)F^so%.p)OBp ?"H6ew:7d2hM|{ohN}',]у5@Eq1AQQyƃZR>?( ńtȇt# Ll3@&KK>Ǖn VOhk^1C>W0o"e8RA#>Jh4b}|'׫̹!Dh%WjBo NUGM '(nv C޴>-Ϛ&k e´`2&Tn'}έv|Uw]Pᮠѧ3Q/塶ОQVۿ/0L+psv?%9ZgmNcx8i*UHQqE8\ [Nl{%ؘt> +;s bKmUBCvRri7qnpb1EX/5jt/Jk-%)DQ͔]r*G $@ &*(9Uֱb/ ӷl_ɣTj]W~0,=u.f/$Gf{db}I?>E@d;_\ eЭ;)`KhBwRXv!:awWs9Fy7l A`ۖE.ŀbv­XmNK *&tI8?d%y<8mVaQqhtOT$Δ"6nM$uf&lfV mO>OY~E_dG/?\bwuϣ -fan#Bi5* 5rV4+ۦ(35~t?_ТMZ#xCU`+f2s#@"փ.1 Q~6INJ6_L =I Xv:N_xr!Ev.*>Z))t+:L쐉! r-9Q)/ ^Y".>rJ%Cwi!0UW`<@cOIɸ@CK(.xLXcv}Hܷ#1SQ,7)ʉ)`vltcE% J3'O6Od`ہRYiz-8kSަmh73cYvJ0E~B;IpjB5}Ub0|Bh~!XҺy]6QU"VcȵY⾙X߄b<n=^:;.ŒTk;czcZ)Mz\LAʲGSvvN2MCe\ ?h䧵RQ_k.H_C5g=U9 Z^H,}%M4Jy@2'F$gB_gk $V7M=g9*BFF7!:ybmUJt?dSA޴AԢ.N$21,M+qlZG'q_2M8CTy 94|^M-S9Wu^3noTÃ.L{qb:\s\Zlo]BI,F$`X|ab]\ǺvwX&焳DYk֙QW.+Fj_w"GJٙuV(Ay坉 #Q8lV̒ya Z'7)j\mB/ghxRփ 8 J%"Δ†jf T$ͼstު~'`]4`2"v$ &bzS>ܬjH`",-nUFt7o;|G5%EE;O6mX|u6vL'\Oh h{NJw}p GnԌ n+>=.d;ک%rMOˉh̝j3Gv$]1OhTeIȳn* ޘJjBtrB{'۲u Y+N[zS:9ؓYfxE8氱O`WMat-K&r5QR-&NZ!ZzҨ6qĬB0bH1o$B5kȀ,ȧT|/0˳FP7.)# 7-eo H~/`53+ rњݜcGh~kC :ZX~+SDH7/#%s|,&Xʲ/Dτ2DA^;;Lfd>e3ҫest;np&L]2D(菚ۘ!D N59W۳`GٝىxP4'"{@ߗ,erA . vhN+j04O+^jqu/4'fFkm]i)RA u2BhOHmvy+vv{%0U&k;B?ɶ+S&D_@[Ba=ް{Ar}SKp JrzkY-ٳXcA0;7M vڶ`#zHՅI  ]yBbz5)K|.+qt#`;&eR4U\ w|؄]gɚyL" %q*r,T3ר3X5yi^CK"2>q$Դz|ܳ7~vNYv_Kx:kZuX)UCcS'K!x/Wz(ض?ĺ5m6>Vj5W'9#6/)Kې-"gIЏ a5!LF@b* nF5y'+O#TDÎ)>+d!}-)Xku h0 G!ɇSC@ˮS M +@فrN6~6{ ̸_i˼1 Rr-pV?*MHfwg~As/17攰Cbp?!2Y,N3(€ҥr?Y)K !E 5]UyQ.j+K¤GLi}>8sVѢbdj%а ]j?Cdbb ɂ=5WL3lvnTtkq-wd҄Զ6d{ ɘ)XӮr1fy/CĴq:|(\[ߤ>{$"aEԲ/EŞol||0eahα%ƥzH85 wqG=C^||otTkGwndNeNʠBD$U~M"&#EG: RhV]};s:^HC] 'VT[X|NˏFte)EQ3Ar^W\*~(5AsBHMG˨NW[eM-C52ihIge bm1)unKϟVu\Kƒ+ 0Hf#KQF@y6)@#&,Vs>N)Dș=RaMO3 r%AGUz CKZdtJVs|w6zYL!rm AU@>} ZF$Spn{@M" b\#+̯r0 yv^k<<=ԝ7a |0 IPR;#wJArٔ7;, 'WY#`y aӮTSv86 :~jRL@Ƽ3׹DqL%mn jdOf /MA:> O(S!<-{ F1O1eNJW (H}x>(G0O7P| xef"87 !'Izf~"7'8 Q1E5[n;߂s3, ʢܐȥ<כwN!R`7t6RY5JzF=ˋGZ'ٳ-Yp^ů@ވ ww6>:O=3]$ Zt6}e܋ Kk%y%aqo3 |[uŀ+8|[4y0!,^flHHKѪ ,wB|8MV/6U ( Ng;)@^8wGNoܥ"7^Ί"41s VҔ}?ٶ$Arx?$|"dLshR_}QQ6,g34胗6wT;:nS_ u"qv'W~G']| Tp/0aW o0;-!F&ۈw:W%_0D`?R7ŋj-N lPD,S` eEE>@ uMl'u&x<̖6lζ~l,9ɮ%Xٲ˥PK%*/D'jѷAcjf:S 2Bm,wci&}{Fw$4vtR{Ŵw (>iw 2p4"wqQ;[m'Qꦗ د?$((!wrO0e᠂~Py;*l1Xo6%(J#UX)K73^ f֭E6iDT㦡,moM/i|^nL5#+ଏ%',"e׹~yo)^kw+ԶIuB7A_mן|&n]`6մ8 jR dwg"`:ʱ ,Xx4f~v3C# ЏmhA$Mbd: {6|^ꩴ7NqYV> G #_,-RX%D9DGLiX͕NrV`:)2Ҏ@kty/^˂ErE߬J2g5N|mDbi?xzKd+NpcW;CsG0i^W5 <,BԝmJ%"eLAGF҆CKG[،/gžpٰa(KNm ^[* Y*2SB-LGJyra`)/ aVd o|Q[RܴPrz hD5l[Oh$-LĊ'571OtNX͑tüwxŽi 0 @+1lmqgkQdWP;|U:~,82B]Ad>Z70d!b$_XEgv~ia%ݳKԯ$(}^Sp*, $DRAA|,k{(=s DQhҫ+!'`L^7G+Q$ȣk:i*!$ږmUT? pJ=6YPCS1zMСxO<[Kh2O W]yJP%@¢3A*}8pgD?Vl {qUb)Oht=ȣ~i/GRVJ8dfԨ|) JS:0T[wG=wZG-lb9IۨVZž|5/`6NCHSuw|zl[Yct?O)_|>\V0]b;1YLNu-Aqׄd$`Vbk['J#׿=ۧW(tN}\.w2n:)cu`Y!6=ScU Me{J7kŷzྌ$:y?!koeL;ܺ-K3LJ͔&9+I*oS;9k^;Y0)3y!EAV%,R12Q6xvX,hIHiޅNk'`_~ܢ$'hi'% !\̕d"$wi)[Ā~zc߿ylx03p @DrDI,V߶ehyIX¸jjDbpCN+]xJO[^ 3군f ,pR]$kcnIB} /C48a FWDPǜr2(,݀N_67H d!ds/´5 tt6 )Q ?L&{piھE5A%άvd;.~-l&^B Վ !x- `1bdT8vY>Ŀ{X#Էfo-6zO]F^LkBPh ±b({,pU KfJݻh|OX(ѥDV:ĿsN)26N]R)X0{֪-C5bgXmBeSW!JY+211np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._wǟ@ sS|11np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*Me>pv9[riFrq(|a,- g^ UKiJTwjevߟ3"&pZW&0x㬷H^-1^<9XecnK7`=ecgY={>c<~&]Jibd8Y[ٳzz2C ?q^u碑g>}X;d+c'WI٬6X6WDeץyl^jWrJ',lcG}~E5k8ꯃƧ)ʆiSTZ;v~D95`iiwTQ(I,n,Z6XksNNaXPJB/Jd({V[˛sMl#xt)Ҩ+@Gg`MD܄ =28/tjm:~G6{ 1y2xFCJH@;Hx/bTaO#Z5HB["Q#vƢ2mEZ[Yfx_~[cHzva˹SgGezh_$;>ZŮYʝ?qСD zz#!A '}!-/;bV֓kAz1t]CܳyAQ,½zkeAu!Z-M*1j׀ F:S ƭ? &65ɁSЏ_y;5Пn7mUr9QnIJT̮q1]fV s2LŖ!2UEOF"=3~+`98Kk!oO}K7$vN[\/`2[xlC3yF\?5YbhP;aj ^~^o||Ll6,Wu;~i)Gc\/fl]ĪG(6{;NSzFX%⦂ʾ/VBb;IBl졨.RT h ,z/Qg`Se $c}ȳg\Ի)q|oH*'v OMkR@/'JW\p'gG}mp& Vgi8}@y=b& ~2?֊WtûpnCɐ[a(vC\}Vg43ql񬓩v} ,?]Thƾbi\ުVx qG)oe mV' 䬽k[[`ˈRnܐ|(i_Oz=1>&;}G1[)6qo[C|Te INR4fhכ0Mթ.S;(+R*ʮX~V ] yx.fr54.3.hq-Ͻ,& [b,sk){ٽRVf;7esWr:^*t 0;omV-!R2M_PZt[cx8f7DFhb 0l|) ĥ_a9X)ʅ{^O1ޥ9v3ZgCIzd6:5QmsVR<:*ss>PQPa'LYҩW[41F/;DxYTT+#` ~/=z]L?&T/:i VgI;w#nuP)*Oۦf jV&5dضEc>|gfguG< ޴ >,7{dei}0ҭVu9Q.*qAY3?zg{bv\x)rcg9̽rK.mc\Ѡ~.]Mus?MSs{3ꮯɐq+db)ytUl^a~|!+Y zKF%X5ilcdr̓**L".N?² 0l}.iM2fj~WUzW6blEF&QN->ie`/{zz|C.#,`2ڪ ={Qx +ս<7? Y{ Q26!>B7ۇu~`EҙU!t~qFq#mW4O|11np#_(˅ѕ~*'uMدՐ%S61opMG bd-HxrB:^p"ΉA)>Rn&O 2ӮLRY0~ً(NjuU ~J?j>n'Gzbjzc"EJH| `x~vUL,as{nO4mNI7%J0]o+ĉ!n{}M]Fz6x!1Θ@{uV jn;ښ0g lݢgGh+YR,y֦s=&\` z#`r}̂la5dg!6!{B{5٫q\;|!kc!tY Mэk3s *~c' L~J%ЭM-^O8;#p1{Y@ZU9KUsS|11np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'm*b4\[l!'D0>EH\iƩ].E_p;27 *Z&r 9$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG юo*sS|11np#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY.ɩI{D+ۍGe[vU%y[#&KXkT +W6%m'x2d8cFXSa@]NOj#D^!4d kxEȘ]"Dc_l{N^whi C[)~Sl̎`PӇgҐۛ'~OazaShMڜw-:9Ƴ%P56i|ʎANg;fLݚ˩|ͭok lsz&EވyCb!IxЯ2xbS-3} 8_G 8\Rb2bĮhWD6<ǺI/l)fwp y0s '~8ZJPɘfV``t6&Ty,nͽX: ݻصk&IoeG.콼4bJV^'oGƉh`wɸjѿrS[ ~NP)'D9BS [_ot8Q3Tq {3%֮v;"BLetR)?8 ٸ1ܪˋQ IU `.5(wMu\eQԞ "3Ɲ\4MZ N_wnp :0,.̳SP rhs涰t͜r,̥p+Jy(#7K9Vf~GMuDAkpg^zZ و=KBj}ґ@h~>OHU͋4tXLo4{y߈zm^I1b&#p PWف^6W '/!j1QPU㈟%Xmc^ #k6]v{vS$w#@ppEr4t-ynIh<`3izą;TUA܌_V+T'‘POpHDۺړZ椿דv0H7+l"^CwjꄼuL# llӉu{y&CB`WK2gIٿ]+Fpn -0tDxL'2(ct(\-k[,D:G$啰R_]H]zsf6wyp@GEku:JW۱Ѣ-{P7F}RSvo qvTt|?Q' 1%?r@?U]iTBWW[-Z<)SZ~ZI6N)0Jڡb鰶V ZYOeHDuqyհPXW#u2C }`1[>d֪ޮe#nJ~h G1mԹɪ+( B\*~HDK֤k(~LÙ1;d 9KUwwJKĝǚ(UbVc x\|/DbDR[eTlnPFJ@!^9N.e!Ǻێ ɑ"z-& Kr| z &C!h€`_qoEJ1fi@17k̴ȨRdHM@YuFb Y7N_#CYaE\,[N B$G@ D0fÜ6'| Ƈ{PKb)Sw5*T2W-HddLo|Z2i*5 TA7]ՓÅo |[G6;ĩǦ9@u xN\F2؁cK)N*PrD&ZixDMPE9|WvPU+N_A~A.:XtKKAQ8q =4 \sJ IS&U>aQR3d3`Yq+H5:lhaBߍ}eX5$X)̳~fiJ%NN^Vi)_H3lS@V 緡j0NATAٓG5W8d3kB6B? yT nTRQmd(S'-FD2>AWA(c E{($JPNK aUcv%'h{'Ù@,@ jgLN!)MoխNQx aMGZ͍t覛 \NDo *|L|STZOW]O[w”HPUz@Z_a2~B孒C52&.g%{Iv3']JGltQkP*Uws<#S[Ҧэ ㎤,A#fU]{5Nkk ^(rVN^MӤRo-vPlBg6!rMv2_ ׭rnĈv? d8&Btı =u6_.K{{*!ou&P>.T4UG,ĺOUqa'ئtb\t &҉ iEA3 lANA_AF17؜/Kh#1R: Ea;ݹ&eHoPe~B%QD6WrIshaC8l tIt$KH'[GbOHrC$"w'9xъ"C:Xe+i0\]eojF/W;@D7v˭^rV FRuل̄ZR`C% )()-<8>N'"S"Y^ !oACYGŜCl\RfoN'"nS{u,|O ![lJ$pwd=A]i2!&ӉxdGEF*JavE DNlCu1JV~c뙣P ln"*pޔ !'$"*-מYFb@A$8r@tO{j6NZDB{ h5 Oew5"VU' S,]{O4DVV `I-ʚǝ[j!+.B_ =}uIx'V\ܫGJ"4+bx9 }?Mݭ#Vz8L=H/q,^fUOBUNɗO[ AM]ܩH^G(Jwǁ:va\1 v)&2|?Pp}(+<(1Xt!Ń2:#!5-<7\OgZIH (ļ-#EfHK aeH.m \t6"gp 2xXOzgʋ˜a;Aq&jeǧ) 平>Q]EdT2Zqvc;8psXq'cAL79v-=V6q H YRGj Yti暺HQ%r f L='- 8Д",9T3\ܘ*"37wƏ5QMpuE ?7Ք .YО0Dn0= 3p'yy z8([giqO*pp3B1Gm'&UH`͘pLșRa5H#ؐ#nj (*1FS{躿-ʺ6?FMu<}z,;1D/dFݗ"Ɇ }͖-xcu?n%~!rFvF>c_";{vw^čF2ӣe^zПPbjVJ9֝Mnጋ2ۆ@zѧ C2`ڄ7ů8'i,إ*vZGͷ3&D->CPZ,[WTȍy'ɀú[-`d ?j- Bu(׊P\GrBimAJs tz8h IH;Նy1!x1sT`+X~yVҸ?_[ "{*g/?PaP pzUvOǝ;ff.jeq~Md_ˆKXF#Sv8Qy$m5DR*&}Ɇ$Ib݊,=E$SnW{PÃkCCm!@}Dػr QI#.]2]ib$b 4 VjBhqc(A(xB 3#oKԺ"(\Uf;&n`Šj)u&EEAIC jH`&x5I4*Ј7LЛַ^0WWYR߆,8Bܐ(=\ή:,ڊ_&(lp h3T=%F"Y v?:T£'g&8dx02yËf 3X1uSs`{Z/ `V۳54\(K" Et`IL?43;`Ksq*0~,Wc.{N1P L\v9)Qk/6}%5uK. 3X@ plX=|3iGZUw5y25!L r{ 1%pq.d_Jb?G΀_%C-̳{=˟x y \ B jw"N(Tru"<mpɤtsΒe1SEЍ8L/Oe-B5}C5E'ޚ0[[,Àr^F)gʃdFI:3p~nZ[:U;KkE($|%1; u5;jS8—sO/=sbq\dY T(Nmu%zN@\M鼲mT^sƧz_!E*Q?r6o!14`SkiV57Ǜ܀)|5n?Z!|2ؿk6PF+mkc49]*VV|,srτ`-SŽVs? Z ʘ;/m&x`&OCвQg ec)D9_ĠK>.z6zJaGEwZ>3%b^ 1|dTKE (?/Q @6SZd$y{T/vUhھ sEeLvYEm@&}&:+Qt|b$?fn~e󒿿V7C,o)bgNnW$z񗻴v~OoGcbQm@P : :jӫ+>R4P5Ȩ՛7`s~ Q jFQ1 D0p$nAS~@anl% 3%+H&10|qg $x\3pTVY., }oqPl?"|fll솁lTZY<$VB:nˌMn S(+gTd2D7׵OeI+ծԮXΡ:Zb8 Iߊ2>v{V\V8jCu$Dm]9A4V|8? saK,J/@70lyĞg)St I5PSʦ8g=HJJNE&WM>(rob_Td}+XRS~clq`ԕ/哶QਭB>y65꿎:X-5˜nPr{Š'K?.zLM//lY2[of{Tjm-67 ]Rh~Hk9CB%c~z TQzJ4-+YF 5t g ~n eiVC+Z<3ҿż1|m]W Kӛ˪+rknfΒ~ex)Uݍt >-筈"v?zK?cb$og? -ҁ'|Hu6u.Tb?a*(>Z- 45ú;W$sx > ai!}q9+_2 s<C89˼ϗ@ө SgA$q CKST N 4L6kE'Q3OǟTӋos˟6cx/s2*,IN4'^0d:ߛE%lhc݋i]$eaڈ.B&?C׊:)!2d#" &JCdb[dQ4kT|$].FO1J) '-j1nARN @ԙ55Z)eQ:s~'ߠ˸ {zԕGT)^N:PU2+x{m}DJfA2"\l E_M~>u ',C1wWXv (vCjJsAcRc룂k,M>{2c LUyX;;^"HJ[Bfxwq%4[m4.Om :۰1:UIjK,3 ?R&0L#."_r4 SޝtWg)T&b芪;H é)9C,r$Kcލz.?@Wru3Qu1Ֆ.jO>XYgoG,N[[Z Ut­缾xe 3\K=? Aĺ&VxZt@-" 0XhrG+^Vq_}R&㛽zG2F_*GTw-~%IG۱jj|%QX(q#78w.71=+.k\|1hg I2z*t`& csw} 2(JmwrNNeng9Hp1XCտ,Vkǿ { Θ{jsISW%WgmُVv)Cv8}ҍs\Q) +|ߺr˾A55L&`KDP^`DR$Ude*NQ< (ZȶNWaᄵJcc5Qe2tD6  vP;o"]DZ25EPMƝɇnh"cD;ڑ#7xLQnKP 1s ]6q '%yc|pƍ8^ixo@0^U.<8|zQԋVQOAj>jT6ҹD"8u?!8ƫ& gQtƵ<^RpE3ȥFV/Cz)})Q1<$LA ?~s@ۈ2v) :%nGL!5p!mIN;|A6Rv}n=4lE퓡mԎfN=I+GNRVDFTu,0PT"_KS#@1nq]q\Xk< N{+(OnI!y^8NC Q]$ wS{ `7cLO!bk{B!8pfPWa}>8XGyn[X_Q #A4 h`vSPcy*}V`l?%<[/DKypǀh]ަ8zn/r+:k \CߞZ ,^,y.{Y\Fw/_#ef7z?.?"%.p^ oLQGև@"tت #S, 7$3K %2;XhPYo 0`5O,}Hm쐙$Jua@Z`pƴHo|L=$$o6r BzHB@̹5,Pu!d]l޴ymKcHWo{*D n劑xM?)jy+r$e>c+@jA^Y9@  &=.ŁIl^wT_S+Fi*5f;tEfoO=,Nώ09#|{; (&$hw ֫U?B3Pڅ}BK"'^ҺMI ƌ$% SX.w ¬|c)vmQg5cr% bQ'~h8] T H ]ʔ 8}FǦo'>DMBODZVwz_{>Ҕ~ax%6!yq?/q%_fL?j:+ZnG{宖iAN%cm&j^7toB/.Wy%3&G4m a3Pqe6{lKP yHJ2S(Pk5ZitKw܀b>aIAQ,nOdeo]oLGQfȇ.Gٲ.`HM9j J]K&ٌgW Q /MabT30Cowgkb{ıt\4nh!$itT%$S|>sY7V}|$h\HA xD)$95( X} ] ꩙ 5VgZTa2M⡼ E$ 8x _Ӥ Eͦ@#MY{$3jzqS<KAv⹎ v+|1~ exCn["O|W[5$3O5K(@"9yvGSyeEpsat1^Q93_gu@'\&jV9R+HFG1iaOػyq깠^l&χm B?9/ݪ9g:tK$0G(.B0rQYikRȿYncN0D:Q x<}ZcWWZc%יDr/*xz &,Hރܧs "jgYF{B Q$cEKC Dp3 ll& Fe;}^|p;;|ܪUߐB Db}G+oeַOƊ4 e(~$h0Im`;@)<[pj-, xa)6,rَ&FHx^դ`brr[:y4v¡fKU$8.pZdq(Pݙx 0\9eCGR=x0X [Ж/!2~do ԛ X>#n%ݎ$aC `]] ݪ,?%nA3 k@~X"nJpk<(.5 f078/^Y4u E@0{[ɇhL:!6@fuXZFs$=_O(A@4){MG.Z7{atsT,HQ zC*gs=^pO#kڵFL?NPB͙㡆 seCm!V7ƔK'^Q>kIEFy STfjN/zaZ;".>L;Vir?mt\4xzcr:(Lzʮ:ZW#x -~"|蓒hR/ifIGI,Bx1:[8hKXfL Fxx闠8-e3Q!|c^S(v_h&Y;N*?j7˽NlW%Y.tIϵc.W8(QZ] ^d00ߴhs6 x-øx橈S,44+tT*S,YM߳;jY.]Zr+e[u!ch}&Y7h6UnJ^uLj.aXKw~U:H}+Sxth%5r&8kd{oSP'z6k}E:G6XtU.BkRxk zM)KO ,&[Of)%iTXN?L6[qSccKfBqxY (F|0.Ve%S61opMG ё`݀FsS|1OCItMih CP;-%b\PCe88!_yϞI7PjIߐ<86&~a@#/{1B똳ciñj9SQcچ|zEL" E,2fPM g7592rxBzQ}mxu@k`;.BHN9CDo'nV-:y5Ǥ0KlBˈ?\N&(q=$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'[# 59zO3U1`N:(⿪"b2}e w/*`|Jtc޵ӅSNUTE"[J?#2+pZәQ^p.L2-j,V.pjJV5'R+;6a#Btcy)C{)CveR0aԗ _z/cК x׽䗌lc㋿BO-LMj7jŒ |6ړ4j2~qFq#mW4O|11np#_(˅ѕ~*'uMدՐ"fp)N.J}t?"VNPaVz4='t+ ~:߯0SyxFs)7e;o ͯS«z,#*hrcoaHS=D0s4EUD)b|LR!mP9kgQ)@d:cmDP>/Y? <6ƄY9 ccs-Ns(#i=7Q۳{NVMLnY&n%;pq|mxZ E!p`9OpD<P/SD72Req 0md_~΁j.)[@ԙD&|NFT]xyeԠ4p-t FRD@6a:D^x9J,I;f  Wkᯍ*+aTE(y߅ .pZa3$,^^ìwxKFmFyybvQ${Ə;Rf"r5ĢCglf:!4u~|sei_žOhAZɭ-Z3_'(t*=O;uCpUI`IuUlNX#(_ֈW`%6>&@ZU9ὢ>Tx*%,sS|11np#_(˅ѕ~*'uMدՐ%SZ*g:gӻgrKC΂W~j Օ'ҍ|7.Sh?|qVnVY9x ~,e&o8 ԎA_mwT(KR`ht/&dx\=SnL(ځ3X#aEyd uÿȦ}&C1˜Lm;D҅߰jT`,v~(b,.x yU3zb&/DCXBTUld Tc<4ވ]o2;(b3gmW [Ƃ+XǶ|\dCVB_pw;@\crvF\3"'jF=yCO٨5ҭjP+$s?eRa R>{5ɿ[q#>(AAv w[| )HT6cH B̮w#"vuomLU0(gդkxVOqKOK[? H3Tɐ]KH0pO eT? Tql|kP|?U\빤L2U N5 ?Z-W (gfDL3sږڗ,_ gQ&ʥq`IQ};Jy٪WTG}7ireg8f%+BMMQ}IB]/(rHy'NV r#?Çp>[q#ʖ[K:3V#®ɯP BS=)d ;*lߵ;Ľ._>KfBqxY (F|0.Ve%S61opMG ёU Vr'YvS p{.}{M/HĂFJ4J*f:$RerdM /'/M#]mSk{qfz MhŢI4E#@^RouR@?Z3ţzn|M;18FI%ƛ6 Nӫ@3"'[*j4T~hr ;@ 'zZכ/C=o0d:j.8"7LfE>ahaׁl^(`YXTc|F 儵)|wlDh:͍ho31@=Dۘ@ߟrڦosڽL&7Pmb,5\K(za]}'w+ i3}pzcaqu&q["l~gp\t#[$Ƙ$籌MZa5k$YklS@[Ӄ:TlHŧ.fc!~f]6u@Ex# tpdQ">!F`)t2SfbBH,ʋ$އ\-/Ur(6t,-*?bKV bdKe1^2dJV_>44 `ŷGnk)1ðӞ{X6r_Qf5lR|U[;GqmAj'Hëg 19HYn؋] }MCl -cč l߫Z^1&J< tEVCEJVI=¨i9ED(Njlȗ= 8pWq('2Ӂ9 ਖ਼\OfUi  r]/c J^a9y0+..ЛߘUY_HDAtV-K E99Pҹ L4ƉP>;2Oh=лUNx |4)rtƠ?s o@=\V$Q\E1S5A1V,i/[mv0@itz.s-k +捋Ἰ Ƿz࿗6p 9.HZ5 {U!%T \@LMxVt;b3]8 G%5wǡJq>.7徹$q68?8+2~Tg~z=5$Ww[<ՠh(n6rpoK״V:gټ{Je^ XN8恉3xgηnc FOikAF4ahqvoTLlvrWL:K&A^YqEuz*P4~ *$LBX=JrXup݅|P>36%f dY8(' m+Qj&O/T(Szmq S2Pn)u-@+Fas*w~5X3*k5T(;Z; ˥sOjlA  bNc|߰?:SS@6w{ cL;y%|HyJxOl><\,y0iĩɓ6K,%M^2񮚂hNhS+8M|4/1qGU_Qǧ>pBڣ2= 8RaRg)<3~儇@[#?q'8 {gp6"wF>)np̚!wxO*S +7L#s3cxoC4~[rTVj/ūSH;FQ!yQ"F~/|c .+f2CV aPcS5޺[E ݥգ8@82W奮#85S=%qEdI=hPQ'gmc0y$}%Dq#EpܱfM_\ a|4C_dv/wWw'쓫'E ߑ Z^SCĖא[C"ިͲ5fmՒV؅ZUgtXcrpc!x?KoNȈ)Bj _&G@ r<։+כd¡\K6~,Жsa{q;%B DzRAR[/,VJP'wɼb(m6^TTIrͱ bmj mqK[HҔ}J$Wjz3HFّ?2J1j8 DuI辧msMW]2q2 l)o'TS6}!AQMM0תy5ߚEʇE6hd3*Bﭴ Ȅ8'$Ji0u;|\؄qLnL u fe %nPV]n6TI?d=DS]CІ:-~*pVܪܭHVH*ފ+}u^R=rbڻ4&z_NNwR[0VE4f+,.^~j$iYg:XK,WöBtekDVyWZ̕Λr(y*ջ6 rO= ĜoVgs!tkKfs4[r.VEKO}Hw1 Gإu'yW,|/1zvJi>L;>9HO9"ݖ'owgw?J.WJz lR.-_u̧+XlVФm&L$൚80Kܞڸ~LsRImSfWpEIL 4r]&({VkD?}NFy]Vi9p]r pa%=)Z]R{yYh@7 =Z$z.n}+^J*&̝ ZDrM.rla80ޢ!scfF:/+ ™PqF=Z-91\L`yN/+fX%r?Q}^#̠SHTXwӚqɳr~`:}=m=JڍJa*5YpNTbigE f.Cg6P)&Sw6.i/{2R}o\TqPo6%4vUd8q*Nu}#"orؘb ^5!oܬ َ NbbFe4p( oI~YP-iexu\IGQ/9u#zú{',Bd8&qbqcU&$<" FƷJrv<$1"B<_'׌PVQqI<٫kvN&Ui~zS7I dۋq~ѯN6H %G)f}SMgNƌʔ>厵ճ9*My Eu&}NޖiN6LE%j5FM:+@5S؃<& ệo`7U;'DQ(xBA !A1;kжR+rJCC /Uc*; ȥ⹈٬'p W%B!p U%8DPuc`:W5Y(jׅs)Z6@cV [R\<,yo2ԫڨlWOg!@3kp'X~'*rW1dzkKhn+SF7N%q.y 7jYڿtiAayv}x,Exܧ\2za(0锸!;%fF{HOr$lJbMYt_&yJ)ļiC%ɹ HcP֩< 8>I݄ 0tߥՇv3q 9P֊>3ҼVB2GiԨl+H[^tĮK/ݎwOurչLa;{27 @]*zk+Ob2j#6{> |WW:#k/?ZY~0Hd#g#hcDSG_0Xfo:II00A?Y{~Sc"!kհ.]?^6ϑ,Hp) TZ>~v2"8{dO.+.KCcr+g45WCy.gEa@srOqv B 3V,URY.%&7\Ck:yȸ&5`剢!2B0 XhFf)VF;"VYŦBh`|5_t}6:0>n&"ΛUSÕp X#pDD (-+`w)M&H@n .PigD&y.c#bW]8.U껅+z׏Kumڈ8?RxA:C?3a6\ӻ#pU2ŕ !+:iĕ"i!Gg"˾ !" ?0S5-XV[;{Vjhf„=Ȃ˩oق9: 6L.d{^tv a?=YldH˲n'Hto 3."hk(EUeuqgˏq=䂴dqKNrf<`LnQ7DԛO4ţئrv4&Y>V?_v\XR* [ĂڎqRQKnfڼXu0kbXٛy=#6~>O쟚vpnvwK^pry¡`3 Io˓;|VPGV6JF3M3Of|fǂuFtuWA iȴdTIikEnHS5YloShT BQ~\)AˌV5%eIEaqypb1@XXҕmU[n~78(k9|>w i7aPypofwA5=(i<gt|w6t3Fm6X'MU I"&lH"4 ouDž wo^abװԗhJ?V$Ir5ЃApUqrE]b@nbԈBNl'"RWmk$?;HC=j"3JҜ"GQJb0Zc!UZvUn!u§91IJW\O c 1URu!v\0ZQۥ#h"^YuBXظ`P7zuD ^}2~/a5GN>LLP'QXyEP>AƓӈǯHRHV<-o6W4ˬr@q.S^lno+I{#jҔnENFP%  }qvuYH?eKr+|>D)CtME0W\6Xٔ+L%E^_|3 ^D/*.Cq L`uEQzQ^-}pHnbLt|bHNYj¤ R\+;EVh JfY|n#5ˌ(щiϤ)e sҦ\x:4X^ +v.3Hm2n=}#! 5\DO-o GHoM 8lZwmګ)wK0r p듏޶do_ɱ^f ^}=)|ˑ.%'_.F@fZ.'9NMyr2$#\!7620~jmL\m"%o_ $>:zl4L̼VfkSNg/t|/h֝ 1O^jK֝ mC$"JKzQ i0tp$sA/2v8[ d_l#>`TUӼDTكVCMgUu(-Q>yBwÖvuĪR頁Yu ҼVDEP=Aq549R'JjJPf%4g]vⵂkN.DB^wtŖj`ѵ*UI+1?k] Q@ ~s.r6P/D_ @twCmpLW(i`׈ƸX+Tc̡9[^b:qSiJls)5ta."? & ~FxmIW4vC-EU8tC`t5yXcYӺJg|+mR'v83c} aɳbb/G}k\aQ@LJt=8lx08~S\}UMJ)+Z4"B %E5F.~W\'j ]`PgQr|9l E=RqXHgȇ  t*kԺvgK'9MGw~eG2*G/> %1e; soͧt\чA@nY% S M;*9cq7E" ;8"&bqa!Obt%Rl@o\XΗ(^[ATЭnU==b=QgǵXR?Jj/ fQ=]H-0t?-/u I_uDQgId2GZ:~fFU羁NӑQFvh-Lm;;?S,vMUEGڕ. eW(ʨN8 S9ĉ͕1EcZ ;쒑>Ji~2W D-}X6?0E3i?{X2@Z\ 3ia.xz`( B{þ=,g3$gn?KfF2oY,zLs L;ZKpp.Uz)x@"&QBlߵ;Ľ._>KfBqxY (F|0.VȻ sS|1 rQ폟XƏkJ]oUTp#3 ڗU q_)я;- Q[W?٧*Us7SbsvM/a Kܱ]7v#!Ԩ|qKqF XH8y8v`Ԋ 1F1Yxh^ɘ:cQ ST7#cnI3QDOC jNcpq)"j<1 7(v>5˜!݄]雺u0V< "WׄQKYm'8wn^m!|ܻd;| #{u:#uyu[XYQoӞ#V%rL*OkcvM`:hv.Ԥ3Z葾i<j>s7YBklz`+Nr㐘9[?Ig0Mw'%jXں޺[k9 X~BΎOq rro#/Рgۂ%FGr.:G"4Cljm{'dH{d$g)R#̤vi;`[X,5D@F7wt kR|[PdKڼP= a A|eW)VO ZϺ:jH;+Pe :cVTUmZR8O]Tci,aeEʕ;2ɝI,_/7T`qǫ9w<$yP|'Ft8prR{8 *&]PZW+fѭeZrѨ;.xrDflw|y!,/]*|gj,7-4Ӭb.V:~ͰkGhllY[5&: ] 7{*e "1n#i6. 4#yY9AzPi 6nQ4pl 4)@,AAEnFdF׋&Y)n2M7 ɛ@І\3cuYwȧδ q4%U)Ii)ˆiRek+U -VRк+ l,%,ګ^άVNTNCa-!8I'$/T8,_D$NJ.Xzo~3uP`h>1/D P{v@cL`cߌ~$ gA5pn4LsaY-A6sWc=z}g:VZ'^ŭFmGo'i5.1Ti#y$WčdZNZ ԯ[Rxh=Z̨Y KBSUygd 2m){TmwT= | qyYq_T ~P߾_pwMfsT2]v+D[ xD4ͷ?CH"SHFQiEӎ)U?tNoSgIMޯ-!y3ZiPɚ˙fw!E  u4efJhY0=EJs4PĭvUU%_y=4Q7wEwM.xq =#an2e& T6>_Cx+:{%y6͵lXvRTۆLgYKK x~.Ga?X0\MWsmy!3b}ZQbtI\mޥBˈ?\N&(q=$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBmsS|11np#_(˅ѕ~*'uMدՐ%S61UT̺ՈVk(!\pܵw.^,^Uo"*; O[hJ]L"RdnHxvǮ{LMG}G jF~.\f1N&ޏ U1bq:lj| `ϩ30@Ϥ7| Ñi-73@Zb''H6F6~xj E-e\zU<‹J+Г{^#@qs?XNcC}3L@ dT$8+ SSK q w P[;?{B|bm}?d¾Ã|sjE,4;ȟVXM˦2aS>Wdm`/Rs@6SMb m~mVɕQL~)U1IHUMKfO)ҹpn>~b]8(q=$p#_(˅ѕ~*'uMدՐ%S61opMG ё`α'\YfRXvY[ڭR+t[nOor#,E_֐U&r;O(fuα&# ?}w!nz>SbvY[ڭR+t[ BS=)dߦ:sS|11np#_(d:E d n(}1 #_eNW;+T^>v DvE2-lQSRIt)C\NG" E=^غYj̽nDkf-T[׬+>IoÀ7I3DZ/],ꃞ9Vhé'%q1auXa[f`rAL(rԾ_n;BA9L]FK;40Z=]$B>`T)26 $]%Y|(*ܑm²m>M3pCF=zI{6Vszdrp+w(p}>@sy;FWCH+ Jo2N: @ӫ-rmJc{W G-D(;z#N `-Uq|RT)~*ͽIW+lQ&~,kg'/Ma<Bv18+Pu.E ˸#aD؈bI:`1G?Mz_9+W]iîEahHDn/w̛[![: O?i3vqWds"?qi9xTs(t6 .fZAε!sVcm4|HI? @KB-Y@9SȔfu|71r"_G[qZhݜ 8rsdۆ>T^$=| O`w&D_ 5HA(_\j*,#y!X>2D+\Fr>&@ZU9ὢ>Ve~HtVn̽芭-.α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfB [&Ⱥ+^Dn=,)5+|yFH#dM %baAJw#xW֯">u;O6s͓pTMe.)\J?lu"th^B?[ u %k#%9inVvB>gysT:ֺ3K\WJb𧄙R*'XNh ==z|msгNq#/fLAÝMd](+FU Jڜ%ixo!Ȑ .Q$ G^vSӑj1&o&-=(?K,4BMBW>6x`-~^Q&sKqNփl-Hp'x=Z{bjOЎĮ0c})Wbpl(#x2eݛ gUI/yi20Qٗ%I6{4}{g@d$9TjٽU1̰ ֙EGgE6:+8Fl)I#+\Q2/VI5nì&9 DhuYִ>}I ϓsbkGJD-Uœ{hr|1ұmv}n=4lE퓡mԎfN=I+GNRVDFT \sS|11np#_(˅ѕ~*'uMدՐ%S6)3\B<N4oՉwZZƵF%I C^;Pij>2\mQ9DbROh"& 9#ަn?Ǔ`A߻QHSrV,MWD vhs#Wn̽芭-.α'\YfRXvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY 5xȴ:Ց;*K cދTRV wzbBnb{31V&BdC۝41J::߃X:r;%As9A[#S^jSVk'dmI V䭗N@Mm}Fu`E51O7î2-H"Ǩto!^6 @vbb߱(u:\Q-tuES_G/Q~m1p}oDGDʙ/OD\T;i H8Ւu$zG"zpgUWQH[X;ld#'jLX1#|cm`r^Z{6x(łRi=xfC:0Ls%t_ξmz띮e}"p}X n22N f,Xv+($#:΢JLNe7"ʼnn.Eb Tuoԍ[Īuu׽f4|ldxq-<l,)t4Ȼ`RÇu1fAYZoNFΊA\D` t9'V:hCz @b5]T!ئ3g QJS#rv YU}5l16RIoG"=\/4rJDkNj͐LU՘Th 4ڕEZzOL?>-PH DYh(G!WE|zF%h?"m/4Fʳná붺!U7!כ0/\J/>*``.X @5(~h4bXz&!*F/ހN|crd/+I?y'75TӵԼm3s͏uKӀg͚18{*'/% @@sb1zU]'.YiY:|{+.v@JTKiH4/_95(fuα&# ?}w!nz>SbvY[ڭR+t[ BS=)d ;*lߵ;Ľ._>KfBqxY {0g-sS|11np#_(˄Ne/70kWQK~QU}TRw xV2n2|YXĶwN:_+?j5e>܋ 2=q"9_X(]W }_~Km,ND@G|Oyްv0 dUeN"3Ko߼8ep bӦӢxo!ޗ``atx;x. */ #include #include #include #include #include "ldm.h" int main(int argc, const char *argv[]) { if (argc < 2) { fprintf(stderr, "Usage: %s [ ...]\n", argv[0]); return 1; } #if !GLIB_CHECK_VERSION(2,35,0) g_type_init(); #endif LDM *ldm = ldm_new(); const char **disk = &argv[1]; while(*disk) { GError *err = NULL; if (!ldm_add(ldm, *disk, &err)) { fprintf(stderr, "Error reading LDM: %s\n", err->message); g_object_unref(ldm); g_error_free(err); return 1; } disk++; } GArray *dgs = ldm_get_disk_groups(ldm); for (int i = 0; i < dgs->len; i++) { LDMDiskGroup * const dg = g_array_index(dgs, LDMDiskGroup *, i); { gchar *guid; gchar *name; g_object_get(dg, "guid", &guid, "name", &name, NULL); printf("Disk Group: %s\n", name); printf(" GUID: %s\n", guid); g_free(guid); g_free(name); } GArray *vols = ldm_disk_group_get_volumes(dg); for (int j = 0; j < vols->len; j++) { LDMVolume * const vol = g_array_index(vols, LDMVolume *, j); { gchar *name; gchar *guid; LDMVolumeType type; guint64 size; guint32 part_type; gchar *hint; guint64 chunk_size; g_object_get(vol, "name", &name, "type", &type, "guid", &guid, "size", &size, "part-type", &part_type, "hint", &hint, "chunk-size", &chunk_size, NULL); GEnumValue * const type_v = g_enum_get_value(g_type_class_peek(LDM_TYPE_VOLUME_TYPE), type); GError *err = NULL; gchar *device = ldm_volume_dm_get_device(vol, &err); printf(" Volume: %s\n", name); printf(" GUID: %s\n", guid); printf(" Type: %s\n", type_v->value_nick); printf(" Size: %lu\n", size); printf(" Part Type: %hhu\n", part_type); printf(" Hint: %s\n", hint); printf(" Chunk Size: %lu\n", chunk_size); printf(" Device: %s\n", device); g_free(name); g_free(guid); g_free(hint); g_free(device); if (err) g_error_free(err); } GArray *parts = ldm_volume_get_partitions(vol); for (int k = 0; k < parts->len; k++) { LDMPartition * const part = g_array_index(parts, LDMPartition *, k); { gchar *name; guint64 start; guint64 size; g_object_get(part, "name", &name, "start", &start, "size", &size, NULL); GError *err = NULL; gchar *device = ldm_partition_dm_get_device(part, &err); printf(" Partition: %s\n", name); printf(" Start: %lu\n", start); printf(" Size: %lu\n", size); printf(" Device: %s\n", device); g_free(name); g_free(device); if (err) g_error_free(err); } LDMDisk * const disk = ldm_partition_get_disk(part); { gchar *name; gchar *guid; gchar *device; guint64 data_start; guint64 data_size; guint64 metadata_start; guint64 metadata_size; g_object_get(disk, "name", &name, "guid", &guid, "device", &device, "data-start", &data_start, "data-size", &data_size, "metadata-start", &metadata_start, "metadata-size", &metadata_size, NULL); printf(" Disk: %s\n", name); printf(" GUID: %s\n", guid); printf(" Device: %s\n", device); printf(" Data Start: %lu\n", data_start); printf(" Data Size: %lu\n", data_size); printf(" Metadata Start: %lu\n", metadata_start); printf(" Metadata Size: %lu\n", metadata_size); g_free(name); g_free(guid); g_free(device); } g_object_unref(disk); } g_array_unref(parts); } g_array_unref(vols); } g_array_unref(dgs); dgs = NULL; g_object_unref(ldm); ldm = NULL; return 0; } libldm-libldm-0.2.5/test/partread.c000066400000000000000000000072421402606704000171530ustar00rootroot00000000000000/* partread * Copyright 2012 Red Hat Inc. * * 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 * (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, see . */ #include #include #include #include "mbr.h" #include "gpt.h" int main(int argc, const char *argv[]) { int r; if (argc != 2) { fprintf(stderr, "Usage: %s \n", argv[0]); return 1; } int fd = open(argv[1], O_RDONLY); if (fd == -1) { fprintf(stderr, "Failed to open %s: %m", argv[1]); return 1; } mbr_t mbr; r = mbr_read(fd, &mbr); if (r < 0) { switch (r) { case -MBR_ERROR_INVALID: fprintf(stderr, "Didn't detect an MBR\n"); break; case -MBR_ERROR_READ: fprintf(stderr, "Error reading from %s: %m\n", argv[1]); break; default: fprintf(stderr, "Unknown error reading mbr\n"); } return 1; } printf("Disk Signature: %08X\n", mbr.signature); for (int i = 0; i < 4; i++) { mbr_part_t *part = &mbr.part[i]; printf("Partition %u\n", i); if (part->type == MBR_PART_EMPTY) { printf(" Empty\n"); continue; } printf(" Type: %02X\n", part->type); printf(" First Cylinder: %hu\n", part->first_cylinder); printf(" First Head: %hhu\n", part->first_head); printf(" First Sector: %hhu\n", part->first_sector); printf(" Last Cylinder: %hu\n", part->last_cylinder); printf(" Last Head: %hhu\n", part->last_head); printf(" Last Sector: %hhu\n", part->last_sector); printf(" First LB: %u\n", part->first_lba); printf(" No. Sectors: %u\n", part->n_sectors); } if (mbr.part[0].type != MBR_PART_EFI_PROTECTIVE) return 0; printf("\nDisk has a GPT header\n"); gpt_handle_t *h; r = gpt_open(fd, &h); if (r != 0) { fprintf(stderr, "Error opening GPT: %i\n", r); return 1; } gpt_t gpt; gpt_get_header(h, &gpt); char uuid[37]; uuid_unparse(gpt.disk_guid, uuid); printf("Disk GUID: %s\n", uuid); printf("First usable LBA: %lu\n", gpt.first_usable_lba); printf("Last usable LBA: %lu\n", gpt.last_usable_lba); printf("PTE Array Length: %u\n", gpt.pte_array_len); printf("PTE Size: %u\n", gpt.pte_size); for (int i = 0; i < gpt.pte_array_len; i++) { gpt_pte_t pte; r = gpt_get_pte(h, i, &pte); if (r < 0) { fprintf(stderr, "Error fetching partition %i: %i\n", i, r); return 1; } if (uuid_is_null(pte.type)) continue; printf("\nPTE %i\n", i); uuid_unparse(pte.type, uuid); printf(" Type: %s\n", uuid); uuid_unparse(pte.guid, uuid); printf(" GUID: %s\n", uuid); printf(" First LBA: %lu\n", pte.first_lba); printf(" Last LBA: %lu\n", pte.last_lba); printf(" Flags: %lX\n", pte.flags); printf(" Name: %s\n", pte.name); } gpt_close(h); return 0; }